comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Not an OG" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
require(getStep() == Step.OgMint, "OG mint is not available");
require(_quantity > 0, "Mint 0 has no sense");
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value >= ogPrice * _quantity, "Not enough funds");
require(<FILL_ME>)
require(ogByAddress[msg.sender] + _quantity < maxMintForOg + 1, "Max OG reached for your address");
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
ogByAddress[msg.sender] += uint8(_quantity);
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit OgMintEvent(_quantity, msg.sender);
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| isOgWhiteListed(msg.sender,_proof),"Not an OG" | 234,785 | isOgWhiteListed(msg.sender,_proof) |
"Max OG reached for your address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
require(getStep() == Step.OgMint, "OG mint is not available");
require(_quantity > 0, "Mint 0 has no sense");
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value >= ogPrice * _quantity, "Not enough funds");
require(isOgWhiteListed(msg.sender, _proof), "Not an OG");
require(<FILL_ME>)
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
ogByAddress[msg.sender] += uint8(_quantity);
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit OgMintEvent(_quantity, msg.sender);
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| ogByAddress[msg.sender]+_quantity<maxMintForOg+1,"Max OG reached for your address" | 234,785 | ogByAddress[msg.sender]+_quantity<maxMintForOg+1 |
"Max per wallet reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
require(getStep() == Step.OgMint, "OG mint is not available");
require(_quantity > 0, "Mint 0 has no sense");
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value >= ogPrice * _quantity, "Not enough funds");
require(isOgWhiteListed(msg.sender, _proof), "Not an OG");
require(ogByAddress[msg.sender] + _quantity < maxMintForOg + 1, "Max OG reached for your address");
require(<FILL_ME>)
ogByAddress[msg.sender] += uint8(_quantity);
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit OgMintEvent(_quantity, msg.sender);
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| nftByAddress[msg.sender]+_quantity<maxMintPerAddress+1,"Max per wallet reached" | 234,785 | nftByAddress[msg.sender]+_quantity<maxMintPerAddress+1 |
"Whitelist mint is not available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
require(<FILL_ME>)
require(_quantity > 0, "Mint 0 has no sense");
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value >= whitelistPrice * _quantity, "Not enough funds");
require(isWhiteListed(msg.sender, _proof), "Not whitelisted");
require(whitelistByAddress[msg.sender] + _quantity < maxMintForWhitelist + 1, "Max whitelist reached for your address");
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
whitelistByAddress[msg.sender] += uint8(_quantity);
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit WhitelistMintEvent(_quantity, msg.sender);
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| getStep()==Step.WhitelistMint,"Whitelist mint is not available" | 234,785 | getStep()==Step.WhitelistMint |
"Max whitelist reached for your address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
require(getStep() == Step.WhitelistMint, "Whitelist mint is not available");
require(_quantity > 0, "Mint 0 has no sense");
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value >= whitelistPrice * _quantity, "Not enough funds");
require(isWhiteListed(msg.sender, _proof), "Not whitelisted");
require(<FILL_ME>)
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
whitelistByAddress[msg.sender] += uint8(_quantity);
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit WhitelistMintEvent(_quantity, msg.sender);
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| whitelistByAddress[msg.sender]+_quantity<maxMintForWhitelist+1,"Max whitelist reached for your address" | 234,785 | whitelistByAddress[msg.sender]+_quantity<maxMintForWhitelist+1 |
"Public mint is not available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
require(<FILL_ME>)
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
if (
freeMintUntilSupply > 0 &&
totalMinted() + _quantity <= freeMintUntilSupply
) {
require(_quantity < freeMintMaxPerTx + 1, "Max NFTs per transaction reached");
require(nftByAddress[msg.sender] + _quantity < freeMintMaxPerAddress + 1, "Max per wallet reached");
} else {
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(msg.value >= _quantity * price, "Insufficient funds");
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
}
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit MintEvent(_quantity, msg.sender);
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| getStep()==Step.PublicMint,"Public mint is not available" | 234,785 | getStep()==Step.PublicMint |
"Max per wallet reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
require(getStep() == Step.PublicMint, "Public mint is not available");
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
if (
freeMintUntilSupply > 0 &&
totalMinted() + _quantity <= freeMintUntilSupply
) {
require(_quantity < freeMintMaxPerTx + 1, "Max NFTs per transaction reached");
require(<FILL_ME>)
} else {
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(msg.value >= _quantity * price, "Insufficient funds");
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
}
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit MintEvent(_quantity, msg.sender);
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| nftByAddress[msg.sender]+_quantity<freeMintMaxPerAddress+1,"Max per wallet reached" | 234,785 | nftByAddress[msg.sender]+_quantity<freeMintMaxPerAddress+1 |
"Sold out!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
require(<FILL_ME>)
require(_supply >= totalMinted());
maxSupply = _supply;
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
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)
{
}
}
| totalMinted()<maxSupply,"Sold out!" | 234,785 | totalMinted()<maxSupply |
"Max Mint amount reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract AllFockedNFT is ERC721A, Ownable, ReentrancyGuard {
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public publicSupply = 4; // supply open to all
uint256 public reservedSupply = 2; // supply reserved
uint256 public maxSupply = publicSupply + reservedSupply; // total supply
uint256 public maxMintAmountPerAddress = 2;
bool paused = true;
bool public revealed = false;
constructor(
string memory _hiddenMetadataUri
) ERC721A("AllFocked NFT", "AFK") {
}
modifier mintCompliance(uint256 _mintAmount) {
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= publicSupply, "Max supply exceeded!");
_;
}
// mint function open to all
function mint(uint256 _mintAmount) public mintCompliance(_mintAmount) {
}
// Admin mint for - able to mint both reserved & unreserved supply
function mintForAddress(address _receiver,uint256 _mintAmount) public onlyOwner {
}
// starting tokenid
function _startTokenId() internal view virtual override returns (uint256) {
}
// get the tokenURI of the
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Punishment for undercutters , who list below floor price - their token will get burned
function getFocked(uint256 tokenId) public onlyOwner {
}
// revealed state
function setRevealed(bool _state) public onlyOwner {
}
// set reserved supply
function setReservedSupply(uint256 _resSupply) public onlyOwner {
}
// setter function to set max number of supply open for minting by public
function setPublicSupply(uint256 _publicSupply) public onlyOwner {
}
// set max mint per address
function setMaxMintPerAddress(uint256 _maxMintAmountPerAddress) public onlyOwner {
}
// set hidden metadata uri
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// set base uri
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
// set uri suffix
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
// set paused state
function setPaused(bool _state) public onlyOwner {
}
// withdraw the value
function withdraw() public onlyOwner nonReentrant {
}
// set base uri / uriPrefix
function _baseURI() internal view virtual override returns (string memory) {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxMintAmountPerAddress,"Max Mint amount reached" | 234,825 | balanceOf(msg.sender)+_mintAmount<=maxMintAmountPerAddress |
"Max supply exceeded!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract AllFockedNFT is ERC721A, Ownable, ReentrancyGuard {
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public publicSupply = 4; // supply open to all
uint256 public reservedSupply = 2; // supply reserved
uint256 public maxSupply = publicSupply + reservedSupply; // total supply
uint256 public maxMintAmountPerAddress = 2;
bool paused = true;
bool public revealed = false;
constructor(
string memory _hiddenMetadataUri
) ERC721A("AllFocked NFT", "AFK") {
}
modifier mintCompliance(uint256 _mintAmount) {
require(balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerAddress, "Max Mint amount reached");
require(<FILL_ME>)
_;
}
// mint function open to all
function mint(uint256 _mintAmount) public mintCompliance(_mintAmount) {
}
// Admin mint for - able to mint both reserved & unreserved supply
function mintForAddress(address _receiver,uint256 _mintAmount) public onlyOwner {
}
// starting tokenid
function _startTokenId() internal view virtual override returns (uint256) {
}
// get the tokenURI of the
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Punishment for undercutters , who list below floor price - their token will get burned
function getFocked(uint256 tokenId) public onlyOwner {
}
// revealed state
function setRevealed(bool _state) public onlyOwner {
}
// set reserved supply
function setReservedSupply(uint256 _resSupply) public onlyOwner {
}
// setter function to set max number of supply open for minting by public
function setPublicSupply(uint256 _publicSupply) public onlyOwner {
}
// set max mint per address
function setMaxMintPerAddress(uint256 _maxMintAmountPerAddress) public onlyOwner {
}
// set hidden metadata uri
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// set base uri
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
// set uri suffix
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
// set paused state
function setPaused(bool _state) public onlyOwner {
}
// withdraw the value
function withdraw() public onlyOwner nonReentrant {
}
// set base uri / uriPrefix
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount<=publicSupply,"Max supply exceeded!" | 234,825 | totalSupply()+_mintAmount<=publicSupply |
"Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
require(block.timestamp >= privateSaleTime && block.timestamp < privateSaleTime + 7 days, "The time does not match");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(user2privateSaleAmount[msg.sender] + amount <= maxPrivateAmount, "Insufficient amount available for purchase");
require(totalPrivateSaleAmount + amount <= privateCap, "Insufficient amount available for purchase");
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2privateSaleAmount[msg.sender] += amount;
totalPrivateSaleAmount += amount;
emit ParticipateInPrivateSale(msg.sender, user2privateSaleAmount[msg.sender]);
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
}
function publicSale(uint256 amount) external {
}
function withdraw(address to) external onlyOwner {
}
}
| MerkleProof.verify(proof,privateSaleMerkleRoot,leaf),"Invalid proof" | 234,849 | MerkleProof.verify(proof,privateSaleMerkleRoot,leaf) |
"Insufficient amount available for purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
require(block.timestamp >= privateSaleTime && block.timestamp < privateSaleTime + 7 days, "The time does not match");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, privateSaleMerkleRoot, leaf), "Invalid proof");
require(<FILL_ME>)
require(totalPrivateSaleAmount + amount <= privateCap, "Insufficient amount available for purchase");
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2privateSaleAmount[msg.sender] += amount;
totalPrivateSaleAmount += amount;
emit ParticipateInPrivateSale(msg.sender, user2privateSaleAmount[msg.sender]);
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
}
function publicSale(uint256 amount) external {
}
function withdraw(address to) external onlyOwner {
}
}
| user2privateSaleAmount[msg.sender]+amount<=maxPrivateAmount,"Insufficient amount available for purchase" | 234,849 | user2privateSaleAmount[msg.sender]+amount<=maxPrivateAmount |
"Insufficient amount available for purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
require(block.timestamp >= privateSaleTime && block.timestamp < privateSaleTime + 7 days, "The time does not match");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, privateSaleMerkleRoot, leaf), "Invalid proof");
require(user2privateSaleAmount[msg.sender] + amount <= maxPrivateAmount, "Insufficient amount available for purchase");
require(<FILL_ME>)
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2privateSaleAmount[msg.sender] += amount;
totalPrivateSaleAmount += amount;
emit ParticipateInPrivateSale(msg.sender, user2privateSaleAmount[msg.sender]);
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
}
function publicSale(uint256 amount) external {
}
function withdraw(address to) external onlyOwner {
}
}
| totalPrivateSaleAmount+amount<=privateCap,"Insufficient amount available for purchase" | 234,849 | totalPrivateSaleAmount+amount<=privateCap |
"Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
require(block.timestamp >= whiteListSaleTime, "The time does not match");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(user2whiteListSaleAmount[msg.sender] + amount <= maxWhiteListAmount, "Insufficient amount available for purchase");
require(totalWhiteListSaleAmount + amount <= whiteListCap, "Insufficient amount available for purchase");
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2whiteListSaleAmount[msg.sender] += amount;
totalWhiteListSaleAmount += amount;
emit ParticipateInWhiteListSale(msg.sender, user2whiteListSaleAmount[msg.sender]);
}
function publicSale(uint256 amount) external {
}
function withdraw(address to) external onlyOwner {
}
}
| MerkleProof.verify(proof,whiteListSaleMerkleRoot,leaf),"Invalid proof" | 234,849 | MerkleProof.verify(proof,whiteListSaleMerkleRoot,leaf) |
"Insufficient amount available for purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
require(block.timestamp >= whiteListSaleTime, "The time does not match");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, whiteListSaleMerkleRoot, leaf), "Invalid proof");
require(<FILL_ME>)
require(totalWhiteListSaleAmount + amount <= whiteListCap, "Insufficient amount available for purchase");
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2whiteListSaleAmount[msg.sender] += amount;
totalWhiteListSaleAmount += amount;
emit ParticipateInWhiteListSale(msg.sender, user2whiteListSaleAmount[msg.sender]);
}
function publicSale(uint256 amount) external {
}
function withdraw(address to) external onlyOwner {
}
}
| user2whiteListSaleAmount[msg.sender]+amount<=maxWhiteListAmount,"Insufficient amount available for purchase" | 234,849 | user2whiteListSaleAmount[msg.sender]+amount<=maxWhiteListAmount |
"Insufficient amount available for purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
require(block.timestamp >= whiteListSaleTime, "The time does not match");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, whiteListSaleMerkleRoot, leaf), "Invalid proof");
require(user2whiteListSaleAmount[msg.sender] + amount <= maxWhiteListAmount, "Insufficient amount available for purchase");
require(<FILL_ME>)
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2whiteListSaleAmount[msg.sender] += amount;
totalWhiteListSaleAmount += amount;
emit ParticipateInWhiteListSale(msg.sender, user2whiteListSaleAmount[msg.sender]);
}
function publicSale(uint256 amount) external {
}
function withdraw(address to) external onlyOwner {
}
}
| totalWhiteListSaleAmount+amount<=whiteListCap,"Insufficient amount available for purchase" | 234,849 | totalWhiteListSaleAmount+amount<=whiteListCap |
"Insufficient amount available for purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
}
function publicSale(uint256 amount) external {
require(block.timestamp >= publicSaleTime, "The time does not match");
require(<FILL_ME>)
require(totalPrivateSaleAmount + totalWhiteListSaleAmount + (totalpublicSaleAmount + amount) * 5 / 6 <= totalCap, "Insufficient amount available for purchase");
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2PublicSaleAmount[msg.sender] += amount;
totalpublicSaleAmount += amount;
emit ParticipateInPublicSale(msg.sender, user2PublicSaleAmount[msg.sender]);
}
function withdraw(address to) external onlyOwner {
}
}
| user2PublicSaleAmount[msg.sender]+amount<=maxPublicAmount,"Insufficient amount available for purchase" | 234,849 | user2PublicSaleAmount[msg.sender]+amount<=maxPublicAmount |
"Insufficient amount available for purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract VINEIDO is Ownable {
bytes32 public privateSaleMerkleRoot;
bytes32 public whiteListSaleMerkleRoot;
uint256 public privateSaleTime;
uint256 public whiteListSaleTime;
uint256 public publicSaleTime;
uint256 public privateCap = 300_000 * 1e6;
uint256 public whiteListCap = 200_000 * 1e6;
uint256 public totalCap = 500_000 * 1e6;
uint256 public totalPrivateSaleAmount;
uint256 public totalWhiteListSaleAmount;
uint256 public totalpublicSaleAmount;
uint256 public maxPrivateAmount = 10_000 * 1e6;
uint256 public maxWhiteListAmount = 2_000 * 1e6;
uint256 public maxPublicAmount = 1_000 * 1e6;
IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
mapping (address => uint256) public user2privateSaleAmount;
mapping (address => uint256) public user2whiteListSaleAmount;
mapping (address => uint256) public user2PublicSaleAmount;
event ParticipateInPrivateSale(address user, uint256 amount);
event ParticipateInWhiteListSale(address user, uint256 amount);
event ParticipateInPublicSale(address user, uint256 amount);
constructor(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) Ownable(msg.sender) {
}
function setMerkleRoot(bytes32 _privateSaleMerkleRoot, bytes32 _whiteListSaleMerkleRoot) external onlyOwner {
}
function setTime(uint256 _privateSaleTime, uint256 _whiteListSaleTime, uint256 _publicSaleTime) external onlyOwner {
}
function privateSale(bytes32[] memory proof, uint256 amount) external {
}
function whiteListSale(bytes32[] memory proof, uint256 amount) external {
}
function publicSale(uint256 amount) external {
require(block.timestamp >= publicSaleTime, "The time does not match");
require(user2PublicSaleAmount[msg.sender] + amount <= maxPublicAmount, "Insufficient amount available for purchase");
require(<FILL_ME>)
bool success = USDC.transferFrom(msg.sender, address(this), amount);
require(success, "Transfer failed");
user2PublicSaleAmount[msg.sender] += amount;
totalpublicSaleAmount += amount;
emit ParticipateInPublicSale(msg.sender, user2PublicSaleAmount[msg.sender]);
}
function withdraw(address to) external onlyOwner {
}
}
| totalPrivateSaleAmount+totalWhiteListSaleAmount+(totalpublicSaleAmount+amount)*5/6<=totalCap,"Insufficient amount available for purchase" | 234,849 | totalPrivateSaleAmount+totalWhiteListSaleAmount+(totalpublicSaleAmount+amount)*5/6<=totalCap |
"SocMarket: nonce too small" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import {Ownable} from "./Ownable.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";
import {IERC721} from "./IERC721.sol";
import {SignatureChecker} from "./SignatureChecker.sol";
interface TokenTransferManager {
function transferERC721Token(address collection, address from, address to,uint256 tokenId) external;
function transferERC20Tokens(address token, address from, address to, uint amount ) external;
}
contract SocMarket is Ownable{
using SafeERC20 for IERC20;
// keccak256("SellOrder(uint8 saleKind,address maker,address collection,uint256 tokenId,address fToken,uint256 price,uint256 nonce,uint256 startTime,uint256 endTime)")
bytes32 internal constant SELL_ORDER_HASH = 0x179868c752420cd3366071e2bfc82d70428afb225a818c94ae9a2acbb53c6a30;
struct SellOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the sell order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
uint256 nonce; // order nonce (must be unique unless new maker order is meant to override existing one e.g., lower ask price)
uint256 startTime; // startTime in timestamp
uint256 endTime; // endTime in timestamp
}
struct BuyOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the buy order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
}
struct Sig {
uint8 v; // v: parameter (27 or 28)
bytes32 r; // r: parameter
bytes32 s; // s: parameter
}
uint256 public maxFee = 10000; // 100%
uint256 public protocolFee = 500; //2.5%
mapping(address => uint256) public vipBalance;
mapping(address => uint256) public addressMinNonce;
/* Cancelled / finalized orders, by hash. */
mapping(bytes32 => bool) internal cancelledOrFinalized;
bytes32 public DOMAIN_SEPARATOR;
address public protocolFeeRecipient;
address public tokenTransferProxy;
event OrderCancelled (bytes32 indexed hash);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(
address _protocolFeeRecipient,
address _tokenTransferProxy
) {
}
//sell nft or other token.
function hash(SellOrder memory order) internal pure returns (bytes32) {
}
function updateProtocolFeeRecipient(address _protocolFeeRecipient) public onlyOwner{
}
function updateTokenTransferProxy(address _tokenTransferProxy) public onlyOwner{
}
function updateAddressMinNonce(uint256 nonce) public {
require(<FILL_ME>)
addressMinNonce[msg.sender] = nonce;
}
/**
* @notice Verify the validity of the maker order
* @param sell maker order
* @param orderHash computed hash for the order
*/
function _validateOrder(
SellOrder memory sell,
bytes32 orderHash,
Sig memory sig
) internal view {
}
/**
* @notice Transfer ERC721 token
* @param collection address of the collection
* @param from address of the sender
* @param to address of the recipient
* @param tokenId tokenId
* @dev For ERC721, amount is not used
*/
function transferERC721Token(
address collection,
address from,
address to,
uint256 tokenId
) internal {
}
/**
* @dev Transfer tokens
* @param token Token to transfer
* @param from Address to charge fees
* @param to Address to receive fees
* @param amount Amount of protocol tokens to charge
*/
function transferERC20Tokens(
address token,
address from,
address to,
uint amount
) internal {
}
/**
* @notice Check whether a taker bid order can be executed against a maker ask
* @param buy taker bid order
* @param sell maker ask order
*/
function _orderMatch(
BuyOrder memory buy,
SellOrder memory sell
) internal view {
}
/**
* Call atomicMatch_ to exchange NFT with Token
*/
function atomicMatch_(
address[6] memory addrs,
uint8[2] memory saleKinds,
uint256[4] memory tokenAndPrice,
uint256[3] memory nonceAndTimes,
uint8 v,
bytes32[2] memory rss
) public {
}
//msg.sender always equals to buy.taker
function atomicMatch(
SellOrder memory sell,
Sig memory sellSig,
BuyOrder memory buy
) internal {
}
function cancelOrder_(
uint8 saleKind,
address maker,
address collection,
uint256 tokenId,
address ftoken,
uint256 price,
uint256 nonce,
uint256 startTime,
uint256 endTime
) public {
}
function cancelOrder(SellOrder memory order)
internal
{
}
}
| addressMinNonce[msg.sender]<nonce,"SocMarket: nonce too small" | 234,911 | addressMinNonce[msg.sender]<nonce |
"Order: order was cancelled or finalized." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import {Ownable} from "./Ownable.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";
import {IERC721} from "./IERC721.sol";
import {SignatureChecker} from "./SignatureChecker.sol";
interface TokenTransferManager {
function transferERC721Token(address collection, address from, address to,uint256 tokenId) external;
function transferERC20Tokens(address token, address from, address to, uint amount ) external;
}
contract SocMarket is Ownable{
using SafeERC20 for IERC20;
// keccak256("SellOrder(uint8 saleKind,address maker,address collection,uint256 tokenId,address fToken,uint256 price,uint256 nonce,uint256 startTime,uint256 endTime)")
bytes32 internal constant SELL_ORDER_HASH = 0x179868c752420cd3366071e2bfc82d70428afb225a818c94ae9a2acbb53c6a30;
struct SellOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the sell order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
uint256 nonce; // order nonce (must be unique unless new maker order is meant to override existing one e.g., lower ask price)
uint256 startTime; // startTime in timestamp
uint256 endTime; // endTime in timestamp
}
struct BuyOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the buy order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
}
struct Sig {
uint8 v; // v: parameter (27 or 28)
bytes32 r; // r: parameter
bytes32 s; // s: parameter
}
uint256 public maxFee = 10000; // 100%
uint256 public protocolFee = 500; //2.5%
mapping(address => uint256) public vipBalance;
mapping(address => uint256) public addressMinNonce;
/* Cancelled / finalized orders, by hash. */
mapping(bytes32 => bool) internal cancelledOrFinalized;
bytes32 public DOMAIN_SEPARATOR;
address public protocolFeeRecipient;
address public tokenTransferProxy;
event OrderCancelled (bytes32 indexed hash);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(
address _protocolFeeRecipient,
address _tokenTransferProxy
) {
}
//sell nft or other token.
function hash(SellOrder memory order) internal pure returns (bytes32) {
}
function updateProtocolFeeRecipient(address _protocolFeeRecipient) public onlyOwner{
}
function updateTokenTransferProxy(address _tokenTransferProxy) public onlyOwner{
}
function updateAddressMinNonce(uint256 nonce) public {
}
/**
* @notice Verify the validity of the maker order
* @param sell maker order
* @param orderHash computed hash for the order
*/
function _validateOrder(
SellOrder memory sell,
bytes32 orderHash,
Sig memory sig
) internal view {
/* Order must have not been canceled or already filled. */
require(<FILL_ME>)
// Verify the maker is not address(0)
require(sell.maker != address(0), "Order: Invalid signer");
// Verify whether order nonce has expired
require(
sell.nonce >= addressMinNonce[sell.maker],
"Order: Matching order expired"
);
// Verify the validity of the signature
require(SignatureChecker.verify(
orderHash,
sell.maker,
sig.v,
sig.r,
sig.s,
DOMAIN_SEPARATOR
),
"Order: Invalid signer");
}
/**
* @notice Transfer ERC721 token
* @param collection address of the collection
* @param from address of the sender
* @param to address of the recipient
* @param tokenId tokenId
* @dev For ERC721, amount is not used
*/
function transferERC721Token(
address collection,
address from,
address to,
uint256 tokenId
) internal {
}
/**
* @dev Transfer tokens
* @param token Token to transfer
* @param from Address to charge fees
* @param to Address to receive fees
* @param amount Amount of protocol tokens to charge
*/
function transferERC20Tokens(
address token,
address from,
address to,
uint amount
) internal {
}
/**
* @notice Check whether a taker bid order can be executed against a maker ask
* @param buy taker bid order
* @param sell maker ask order
*/
function _orderMatch(
BuyOrder memory buy,
SellOrder memory sell
) internal view {
}
/**
* Call atomicMatch_ to exchange NFT with Token
*/
function atomicMatch_(
address[6] memory addrs,
uint8[2] memory saleKinds,
uint256[4] memory tokenAndPrice,
uint256[3] memory nonceAndTimes,
uint8 v,
bytes32[2] memory rss
) public {
}
//msg.sender always equals to buy.taker
function atomicMatch(
SellOrder memory sell,
Sig memory sellSig,
BuyOrder memory buy
) internal {
}
function cancelOrder_(
uint8 saleKind,
address maker,
address collection,
uint256 tokenId,
address ftoken,
uint256 price,
uint256 nonce,
uint256 startTime,
uint256 endTime
) public {
}
function cancelOrder(SellOrder memory order)
internal
{
}
}
| cancelledOrFinalized[orderHash]!=true,"Order: order was cancelled or finalized." | 234,911 | cancelledOrFinalized[orderHash]!=true |
"Order: Invalid signer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import {Ownable} from "./Ownable.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";
import {IERC721} from "./IERC721.sol";
import {SignatureChecker} from "./SignatureChecker.sol";
interface TokenTransferManager {
function transferERC721Token(address collection, address from, address to,uint256 tokenId) external;
function transferERC20Tokens(address token, address from, address to, uint amount ) external;
}
contract SocMarket is Ownable{
using SafeERC20 for IERC20;
// keccak256("SellOrder(uint8 saleKind,address maker,address collection,uint256 tokenId,address fToken,uint256 price,uint256 nonce,uint256 startTime,uint256 endTime)")
bytes32 internal constant SELL_ORDER_HASH = 0x179868c752420cd3366071e2bfc82d70428afb225a818c94ae9a2acbb53c6a30;
struct SellOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the sell order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
uint256 nonce; // order nonce (must be unique unless new maker order is meant to override existing one e.g., lower ask price)
uint256 startTime; // startTime in timestamp
uint256 endTime; // endTime in timestamp
}
struct BuyOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the buy order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
}
struct Sig {
uint8 v; // v: parameter (27 or 28)
bytes32 r; // r: parameter
bytes32 s; // s: parameter
}
uint256 public maxFee = 10000; // 100%
uint256 public protocolFee = 500; //2.5%
mapping(address => uint256) public vipBalance;
mapping(address => uint256) public addressMinNonce;
/* Cancelled / finalized orders, by hash. */
mapping(bytes32 => bool) internal cancelledOrFinalized;
bytes32 public DOMAIN_SEPARATOR;
address public protocolFeeRecipient;
address public tokenTransferProxy;
event OrderCancelled (bytes32 indexed hash);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(
address _protocolFeeRecipient,
address _tokenTransferProxy
) {
}
//sell nft or other token.
function hash(SellOrder memory order) internal pure returns (bytes32) {
}
function updateProtocolFeeRecipient(address _protocolFeeRecipient) public onlyOwner{
}
function updateTokenTransferProxy(address _tokenTransferProxy) public onlyOwner{
}
function updateAddressMinNonce(uint256 nonce) public {
}
/**
* @notice Verify the validity of the maker order
* @param sell maker order
* @param orderHash computed hash for the order
*/
function _validateOrder(
SellOrder memory sell,
bytes32 orderHash,
Sig memory sig
) internal view {
/* Order must have not been canceled or already filled. */
require(
cancelledOrFinalized[orderHash] != true,
"Order: order was cancelled or finalized."
);
// Verify the maker is not address(0)
require(sell.maker != address(0), "Order: Invalid signer");
// Verify whether order nonce has expired
require(
sell.nonce >= addressMinNonce[sell.maker],
"Order: Matching order expired"
);
// Verify the validity of the signature
require(<FILL_ME>)
}
/**
* @notice Transfer ERC721 token
* @param collection address of the collection
* @param from address of the sender
* @param to address of the recipient
* @param tokenId tokenId
* @dev For ERC721, amount is not used
*/
function transferERC721Token(
address collection,
address from,
address to,
uint256 tokenId
) internal {
}
/**
* @dev Transfer tokens
* @param token Token to transfer
* @param from Address to charge fees
* @param to Address to receive fees
* @param amount Amount of protocol tokens to charge
*/
function transferERC20Tokens(
address token,
address from,
address to,
uint amount
) internal {
}
/**
* @notice Check whether a taker bid order can be executed against a maker ask
* @param buy taker bid order
* @param sell maker ask order
*/
function _orderMatch(
BuyOrder memory buy,
SellOrder memory sell
) internal view {
}
/**
* Call atomicMatch_ to exchange NFT with Token
*/
function atomicMatch_(
address[6] memory addrs,
uint8[2] memory saleKinds,
uint256[4] memory tokenAndPrice,
uint256[3] memory nonceAndTimes,
uint8 v,
bytes32[2] memory rss
) public {
}
//msg.sender always equals to buy.taker
function atomicMatch(
SellOrder memory sell,
Sig memory sellSig,
BuyOrder memory buy
) internal {
}
function cancelOrder_(
uint8 saleKind,
address maker,
address collection,
uint256 tokenId,
address ftoken,
uint256 price,
uint256 nonce,
uint256 startTime,
uint256 endTime
) public {
}
function cancelOrder(SellOrder memory order)
internal
{
}
}
| SignatureChecker.verify(orderHash,sell.maker,sig.v,sig.r,sig.s,DOMAIN_SEPARATOR),"Order: Invalid signer" | 234,911 | SignatureChecker.verify(orderHash,sell.maker,sig.v,sig.r,sig.s,DOMAIN_SEPARATOR) |
"SocMarket: buy and sell does not match." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import {Ownable} from "./Ownable.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";
import {IERC721} from "./IERC721.sol";
import {SignatureChecker} from "./SignatureChecker.sol";
interface TokenTransferManager {
function transferERC721Token(address collection, address from, address to,uint256 tokenId) external;
function transferERC20Tokens(address token, address from, address to, uint amount ) external;
}
contract SocMarket is Ownable{
using SafeERC20 for IERC20;
// keccak256("SellOrder(uint8 saleKind,address maker,address collection,uint256 tokenId,address fToken,uint256 price,uint256 nonce,uint256 startTime,uint256 endTime)")
bytes32 internal constant SELL_ORDER_HASH = 0x179868c752420cd3366071e2bfc82d70428afb225a818c94ae9a2acbb53c6a30;
struct SellOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the sell order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
uint256 nonce; // order nonce (must be unique unless new maker order is meant to override existing one e.g., lower ask price)
uint256 startTime; // startTime in timestamp
uint256 endTime; // endTime in timestamp
}
struct BuyOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the buy order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
}
struct Sig {
uint8 v; // v: parameter (27 or 28)
bytes32 r; // r: parameter
bytes32 s; // s: parameter
}
uint256 public maxFee = 10000; // 100%
uint256 public protocolFee = 500; //2.5%
mapping(address => uint256) public vipBalance;
mapping(address => uint256) public addressMinNonce;
/* Cancelled / finalized orders, by hash. */
mapping(bytes32 => bool) internal cancelledOrFinalized;
bytes32 public DOMAIN_SEPARATOR;
address public protocolFeeRecipient;
address public tokenTransferProxy;
event OrderCancelled (bytes32 indexed hash);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(
address _protocolFeeRecipient,
address _tokenTransferProxy
) {
}
//sell nft or other token.
function hash(SellOrder memory order) internal pure returns (bytes32) {
}
function updateProtocolFeeRecipient(address _protocolFeeRecipient) public onlyOwner{
}
function updateTokenTransferProxy(address _tokenTransferProxy) public onlyOwner{
}
function updateAddressMinNonce(uint256 nonce) public {
}
/**
* @notice Verify the validity of the maker order
* @param sell maker order
* @param orderHash computed hash for the order
*/
function _validateOrder(
SellOrder memory sell,
bytes32 orderHash,
Sig memory sig
) internal view {
}
/**
* @notice Transfer ERC721 token
* @param collection address of the collection
* @param from address of the sender
* @param to address of the recipient
* @param tokenId tokenId
* @dev For ERC721, amount is not used
*/
function transferERC721Token(
address collection,
address from,
address to,
uint256 tokenId
) internal {
}
/**
* @dev Transfer tokens
* @param token Token to transfer
* @param from Address to charge fees
* @param to Address to receive fees
* @param amount Amount of protocol tokens to charge
*/
function transferERC20Tokens(
address token,
address from,
address to,
uint amount
) internal {
}
/**
* @notice Check whether a taker bid order can be executed against a maker ask
* @param buy taker bid order
* @param sell maker ask order
*/
function _orderMatch(
BuyOrder memory buy,
SellOrder memory sell
) internal view {
require(<FILL_ME>)
}
/**
* Call atomicMatch_ to exchange NFT with Token
*/
function atomicMatch_(
address[6] memory addrs,
uint8[2] memory saleKinds,
uint256[4] memory tokenAndPrice,
uint256[3] memory nonceAndTimes,
uint8 v,
bytes32[2] memory rss
) public {
}
//msg.sender always equals to buy.taker
function atomicMatch(
SellOrder memory sell,
Sig memory sellSig,
BuyOrder memory buy
) internal {
}
function cancelOrder_(
uint8 saleKind,
address maker,
address collection,
uint256 tokenId,
address ftoken,
uint256 price,
uint256 nonce,
uint256 startTime,
uint256 endTime
) public {
}
function cancelOrder(SellOrder memory order)
internal
{
}
}
| ((sell.fToken==buy.fToken)&&(sell.price==buy.price)&&(sell.collection==buy.collection)&&(sell.tokenId==buy.tokenId)&&(sell.saleKind!=buy.saleKind)&&(sell.startTime<=block.timestamp)&&(sell.endTime>=block.timestamp)),"SocMarket: buy and sell does not match." | 234,911 | ((sell.fToken==buy.fToken)&&(sell.price==buy.price)&&(sell.collection==buy.collection)&&(sell.tokenId==buy.tokenId)&&(sell.saleKind!=buy.saleKind)&&(sell.startTime<=block.timestamp)&&(sell.endTime>=block.timestamp)) |
"Order: Invalid msg.value or token Type." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import {Ownable} from "./Ownable.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";
import {IERC721} from "./IERC721.sol";
import {SignatureChecker} from "./SignatureChecker.sol";
interface TokenTransferManager {
function transferERC721Token(address collection, address from, address to,uint256 tokenId) external;
function transferERC20Tokens(address token, address from, address to, uint amount ) external;
}
contract SocMarket is Ownable{
using SafeERC20 for IERC20;
// keccak256("SellOrder(uint8 saleKind,address maker,address collection,uint256 tokenId,address fToken,uint256 price,uint256 nonce,uint256 startTime,uint256 endTime)")
bytes32 internal constant SELL_ORDER_HASH = 0x179868c752420cd3366071e2bfc82d70428afb225a818c94ae9a2acbb53c6a30;
struct SellOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the sell order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
uint256 nonce; // order nonce (must be unique unless new maker order is meant to override existing one e.g., lower ask price)
uint256 startTime; // startTime in timestamp
uint256 endTime; // endTime in timestamp
}
struct BuyOrder {
uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
address maker; // maker of the buy order
address collection; // collection address
uint256 tokenId; // id of the token
address fToken; // FungibleToke address, 0x : ETH
uint256 price; // price (used as )
}
struct Sig {
uint8 v; // v: parameter (27 or 28)
bytes32 r; // r: parameter
bytes32 s; // s: parameter
}
uint256 public maxFee = 10000; // 100%
uint256 public protocolFee = 500; //2.5%
mapping(address => uint256) public vipBalance;
mapping(address => uint256) public addressMinNonce;
/* Cancelled / finalized orders, by hash. */
mapping(bytes32 => bool) internal cancelledOrFinalized;
bytes32 public DOMAIN_SEPARATOR;
address public protocolFeeRecipient;
address public tokenTransferProxy;
event OrderCancelled (bytes32 indexed hash);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(
address _protocolFeeRecipient,
address _tokenTransferProxy
) {
}
//sell nft or other token.
function hash(SellOrder memory order) internal pure returns (bytes32) {
}
function updateProtocolFeeRecipient(address _protocolFeeRecipient) public onlyOwner{
}
function updateTokenTransferProxy(address _tokenTransferProxy) public onlyOwner{
}
function updateAddressMinNonce(uint256 nonce) public {
}
/**
* @notice Verify the validity of the maker order
* @param sell maker order
* @param orderHash computed hash for the order
*/
function _validateOrder(
SellOrder memory sell,
bytes32 orderHash,
Sig memory sig
) internal view {
}
/**
* @notice Transfer ERC721 token
* @param collection address of the collection
* @param from address of the sender
* @param to address of the recipient
* @param tokenId tokenId
* @dev For ERC721, amount is not used
*/
function transferERC721Token(
address collection,
address from,
address to,
uint256 tokenId
) internal {
}
/**
* @dev Transfer tokens
* @param token Token to transfer
* @param from Address to charge fees
* @param to Address to receive fees
* @param amount Amount of protocol tokens to charge
*/
function transferERC20Tokens(
address token,
address from,
address to,
uint amount
) internal {
}
/**
* @notice Check whether a taker bid order can be executed against a maker ask
* @param buy taker bid order
* @param sell maker ask order
*/
function _orderMatch(
BuyOrder memory buy,
SellOrder memory sell
) internal view {
}
/**
* Call atomicMatch_ to exchange NFT with Token
*/
function atomicMatch_(
address[6] memory addrs,
uint8[2] memory saleKinds,
uint256[4] memory tokenAndPrice,
uint256[3] memory nonceAndTimes,
uint8 v,
bytes32[2] memory rss
) public {
}
//msg.sender always equals to buy.taker
function atomicMatch(
SellOrder memory sell,
Sig memory sellSig,
BuyOrder memory buy
) internal {
require(<FILL_ME>)
bytes32 _orderHash = hash(sell);
_orderMatch(buy, sell);
_validateOrder(sell, _orderHash, sellSig);
//default sellOrder maker is NFT owner
address nftOwner = sell.maker;
address ftOwner = buy.maker;
//sellOrder maker is FungibleToken owner
if(sell.saleKind == 0 && buy.saleKind == 1){
nftOwner = buy.maker;
ftOwner = sell.maker;
}
uint256 protocolFeeAmount = sell.price * protocolFee / maxFee;
uint256 sellAmount = sell.price - protocolFeeAmount;
// PART1.2.2: Transfer ERC20 Token
if(sell.fToken != address(0)){
//Transfer sellAmount to nftOwner
transferERC20Tokens(sell.fToken, ftOwner ,nftOwner, sellAmount);
//Transfer protocol FEE
transferERC20Tokens(sell.fToken, ftOwner, protocolFeeRecipient, protocolFeeAmount);
// PART2: Transfer NFT
transferERC721Token(sell.collection, nftOwner, ftOwner, sell.tokenId);
}
cancelledOrFinalized[_orderHash] = true;
}
function cancelOrder_(
uint8 saleKind,
address maker,
address collection,
uint256 tokenId,
address ftoken,
uint256 price,
uint256 nonce,
uint256 startTime,
uint256 endTime
) public {
}
function cancelOrder(SellOrder memory order)
internal
{
}
}
| (msg.value==0&&sell.fToken!=address(0)),"Order: Invalid msg.value or token Type." | 234,911 | (msg.value==0&&sell.fToken!=address(0)) |
"Invalid Signer" | pragma solidity ^0.8.20;
contract MBLKVesting is OwnableUpgradeable,PausableUpgradeable,ReentrancyGuardUpgradeable,AccessProtectedUpgradable {
IMBLK public MBLK;
mapping(address => bool) private authorizedSigners;
mapping(uint256 => bool) public orders;
bool private initialized;
using ECDSAUpgradeable for bytes32;
event DepositedFunds(address sender,uint256 amount_, uint256 order_);
event CollectedFunds(address sender,uint256 amount_, uint256 order_);
function init(address mblkAddress_) external initializer
{
}
function updateSignerStatus(address signer, bool status) external onlyOwner {
}
function isSigner(address signer) external view returns (bool) {
}
function DepositFunds(bytes memory signature_,uint256 amount_,uint256 order_) external whenNotPaused nonReentrant
{
require(amount_ > 0, "Amount must be greater than zero");
bytes32 msgHash = keccak256(abi.encodePacked(msg.sender,amount_,order_));
bytes32 prefixedHash = msgHash.toEthSignedMessageHash();
address msgSigner = recover(prefixedHash, signature_);
require(<FILL_ME>)
require(orders[order_] == false, "Record already exists");
orders[order_] = true;
MBLK.transferFrom(msg.sender,address(this),amount_);
emit DepositedFunds(msg.sender,amount_,order_);
}
function CollectFunds(bytes memory signature_,uint256 amount_,uint256 order_) external whenNotPaused nonReentrant
{
}
function AdminTransfer(address to, uint256 amount_) external onlyAdmin
{
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function recover(bytes32 hash, bytes memory signature_) private pure returns(address) {
}
}
| authorizedSigners[msgSigner],"Invalid Signer" | 235,067 | authorizedSigners[msgSigner] |
"Record already exists" | pragma solidity ^0.8.20;
contract MBLKVesting is OwnableUpgradeable,PausableUpgradeable,ReentrancyGuardUpgradeable,AccessProtectedUpgradable {
IMBLK public MBLK;
mapping(address => bool) private authorizedSigners;
mapping(uint256 => bool) public orders;
bool private initialized;
using ECDSAUpgradeable for bytes32;
event DepositedFunds(address sender,uint256 amount_, uint256 order_);
event CollectedFunds(address sender,uint256 amount_, uint256 order_);
function init(address mblkAddress_) external initializer
{
}
function updateSignerStatus(address signer, bool status) external onlyOwner {
}
function isSigner(address signer) external view returns (bool) {
}
function DepositFunds(bytes memory signature_,uint256 amount_,uint256 order_) external whenNotPaused nonReentrant
{
require(amount_ > 0, "Amount must be greater than zero");
bytes32 msgHash = keccak256(abi.encodePacked(msg.sender,amount_,order_));
bytes32 prefixedHash = msgHash.toEthSignedMessageHash();
address msgSigner = recover(prefixedHash, signature_);
require(authorizedSigners[msgSigner], "Invalid Signer");
require(<FILL_ME>)
orders[order_] = true;
MBLK.transferFrom(msg.sender,address(this),amount_);
emit DepositedFunds(msg.sender,amount_,order_);
}
function CollectFunds(bytes memory signature_,uint256 amount_,uint256 order_) external whenNotPaused nonReentrant
{
}
function AdminTransfer(address to, uint256 amount_) external onlyAdmin
{
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function recover(bytes32 hash, bytes memory signature_) private pure returns(address) {
}
}
| orders[order_]==false,"Record already exists" | 235,067 | orders[order_]==false |
"Token is already approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
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);
}
interface IUniswapRouter {
function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
}
contract PeeriumToken is IERC20 {
string public constant name = "Peerium";
string public constant symbol = "PIRM";
uint8 public constant decimals = 18;
uint256 public constant initialSupply = 1000000000 * 10**uint256(decimals);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
mapping(address => bool) public admins;
mapping(address => mapping(address => bool)) public approvedTokens;
IUniswapRouter public uniswapRouter;
address[] public uniswapPath;
modifier onlyOwner() {
}
modifier onlyAdmin() {
}
event AdminAdded(address indexed admin);
event AdminRemoved(address indexed admin);
event TokenApproved(address indexed token);
event TokenDisapproved(address indexed token);
constructor() payable {
}
/**
* @dev Returns the total supply of the token.
* @return The total supply.
*/
function totalSupply() external pure override returns (uint256) {
}
/**
* @dev Transfers tokens from the caller to the recipient.
* @param _to The recipient address.
* @param _value The amount of tokens to transfer.
* @return A boolean indicating whether the transfer was successful or not.
*/
function transfer(address _to, uint256 _value) external override returns (bool) {
}
/**
* @dev Approves the spender to spend the caller's tokens.
* @param _spender The spender address.
* @param _value The amount of tokens to approve.
* @return A boolean indicating whether the approval was successful or not.
*/
function approve(address _spender, uint256 _value) external override returns (bool) {
}
/**
* @dev Transfers tokens from the sender to the recipient using the approved allowance.
* @param _from The sender address.
* @param _to The recipient address.
* @param _value The amount of tokens to transfer.
* @return A boolean indicating whether the transfer was successful or not.
*/
function transferFrom(address _from, address _to, uint256 _value) external override returns (bool) {
}
/**
* @dev Adds a new admin.
* @param _admin The address of the new admin.
* @return A boolean indicating whether the operation was successful or not.
*/
function addAdmin(address _admin) external onlyOwner returns (bool) {
}
/**
* @dev Removes an existing admin.
* @param _admin The address of the admin to be removed.
* @return A boolean indicating whether the operation was successful or not.
*/
function removeAdmin(address _admin) external onlyOwner returns (bool) {
}
/**
* @dev Checks if an address is an admin.
* @param _admin The address to check.
* @return A boolean indicating whether the address is an admin or not.
*/
function isAdmin(address _admin) public view returns (bool) {
}
/**
* @dev Adds a token as approved.
* @param _token The address of the token to be approved.
* @return A boolean indicating whether the operation was successful or not.
*/
function approveToken(address _token) external onlyAdmin returns (bool) {
require(<FILL_ME>)
approvedTokens[address(this)][_token] = true;
emit TokenApproved(_token);
return true;
}
/**
* @dev Removes a token from the approved list.
* @param _token The address of the token to be disapproved.
* @return A boolean indicating whether the operation was successful or not.
*/
function disapproveToken(address _token) external onlyAdmin returns (bool) {
}
/**
* @dev Swaps the token for ETH.
* @param _amountIn The amount of tokens to swap.
* @param _amountOutMin The minimum amount of ETH to receive.
* @return An array of amounts, including the amount of tokens swapped and the amount of ETH received.
*/
function swapTokensForEth(uint256 _amountIn, uint256 _amountOutMin) external returns (uint256[] memory) {
}
/**
* @dev Swaps ETH for the token.
* @param _amountOutMin The minimum amount of tokens to receive.
* @return An array of amounts, including the amount of ETH swapped and the amount of tokens received.
*/
function swapEthForTokens(uint256 _amountOutMin) external payable returns (uint256[] memory) {
}
/**
* @dev Retrieves the current token/ETH price from Uniswap.
* @param _amountIn The amount of tokens to query the price for.
* @return An array of amounts, including the token amount and the equivalent ETH amount.
*/
function getTokenEthPrice(uint256 _amountIn) external view returns (uint256[] memory) {
}
}
| !approvedTokens[address(this)][_token],"Token is already approved" | 235,167 | !approvedTokens[address(this)][_token] |
"Token is not approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
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);
}
interface IUniswapRouter {
function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
}
contract PeeriumToken is IERC20 {
string public constant name = "Peerium";
string public constant symbol = "PIRM";
uint8 public constant decimals = 18;
uint256 public constant initialSupply = 1000000000 * 10**uint256(decimals);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
mapping(address => bool) public admins;
mapping(address => mapping(address => bool)) public approvedTokens;
IUniswapRouter public uniswapRouter;
address[] public uniswapPath;
modifier onlyOwner() {
}
modifier onlyAdmin() {
}
event AdminAdded(address indexed admin);
event AdminRemoved(address indexed admin);
event TokenApproved(address indexed token);
event TokenDisapproved(address indexed token);
constructor() payable {
}
/**
* @dev Returns the total supply of the token.
* @return The total supply.
*/
function totalSupply() external pure override returns (uint256) {
}
/**
* @dev Transfers tokens from the caller to the recipient.
* @param _to The recipient address.
* @param _value The amount of tokens to transfer.
* @return A boolean indicating whether the transfer was successful or not.
*/
function transfer(address _to, uint256 _value) external override returns (bool) {
}
/**
* @dev Approves the spender to spend the caller's tokens.
* @param _spender The spender address.
* @param _value The amount of tokens to approve.
* @return A boolean indicating whether the approval was successful or not.
*/
function approve(address _spender, uint256 _value) external override returns (bool) {
}
/**
* @dev Transfers tokens from the sender to the recipient using the approved allowance.
* @param _from The sender address.
* @param _to The recipient address.
* @param _value The amount of tokens to transfer.
* @return A boolean indicating whether the transfer was successful or not.
*/
function transferFrom(address _from, address _to, uint256 _value) external override returns (bool) {
}
/**
* @dev Adds a new admin.
* @param _admin The address of the new admin.
* @return A boolean indicating whether the operation was successful or not.
*/
function addAdmin(address _admin) external onlyOwner returns (bool) {
}
/**
* @dev Removes an existing admin.
* @param _admin The address of the admin to be removed.
* @return A boolean indicating whether the operation was successful or not.
*/
function removeAdmin(address _admin) external onlyOwner returns (bool) {
}
/**
* @dev Checks if an address is an admin.
* @param _admin The address to check.
* @return A boolean indicating whether the address is an admin or not.
*/
function isAdmin(address _admin) public view returns (bool) {
}
/**
* @dev Adds a token as approved.
* @param _token The address of the token to be approved.
* @return A boolean indicating whether the operation was successful or not.
*/
function approveToken(address _token) external onlyAdmin returns (bool) {
}
/**
* @dev Removes a token from the approved list.
* @param _token The address of the token to be disapproved.
* @return A boolean indicating whether the operation was successful or not.
*/
function disapproveToken(address _token) external onlyAdmin returns (bool) {
require(<FILL_ME>)
approvedTokens[address(this)][_token] = false;
emit TokenDisapproved(_token);
return true;
}
/**
* @dev Swaps the token for ETH.
* @param _amountIn The amount of tokens to swap.
* @param _amountOutMin The minimum amount of ETH to receive.
* @return An array of amounts, including the amount of tokens swapped and the amount of ETH received.
*/
function swapTokensForEth(uint256 _amountIn, uint256 _amountOutMin) external returns (uint256[] memory) {
}
/**
* @dev Swaps ETH for the token.
* @param _amountOutMin The minimum amount of tokens to receive.
* @return An array of amounts, including the amount of ETH swapped and the amount of tokens received.
*/
function swapEthForTokens(uint256 _amountOutMin) external payable returns (uint256[] memory) {
}
/**
* @dev Retrieves the current token/ETH price from Uniswap.
* @param _amountIn The amount of tokens to query the price for.
* @return An array of amounts, including the token amount and the equivalent ETH amount.
*/
function getTokenEthPrice(uint256 _amountIn) external view returns (uint256[] memory) {
}
}
| approvedTokens[address(this)][_token],"Token is not approved" | 235,167 | approvedTokens[address(this)][_token] |
"Token not approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
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);
}
interface IUniswapRouter {
function swapExactTokensForETH(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external payable returns (uint256[] memory amounts);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
}
contract PeeriumToken is IERC20 {
string public constant name = "Peerium";
string public constant symbol = "PIRM";
uint8 public constant decimals = 18;
uint256 public constant initialSupply = 1000000000 * 10**uint256(decimals);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
mapping(address => bool) public admins;
mapping(address => mapping(address => bool)) public approvedTokens;
IUniswapRouter public uniswapRouter;
address[] public uniswapPath;
modifier onlyOwner() {
}
modifier onlyAdmin() {
}
event AdminAdded(address indexed admin);
event AdminRemoved(address indexed admin);
event TokenApproved(address indexed token);
event TokenDisapproved(address indexed token);
constructor() payable {
}
/**
* @dev Returns the total supply of the token.
* @return The total supply.
*/
function totalSupply() external pure override returns (uint256) {
}
/**
* @dev Transfers tokens from the caller to the recipient.
* @param _to The recipient address.
* @param _value The amount of tokens to transfer.
* @return A boolean indicating whether the transfer was successful or not.
*/
function transfer(address _to, uint256 _value) external override returns (bool) {
}
/**
* @dev Approves the spender to spend the caller's tokens.
* @param _spender The spender address.
* @param _value The amount of tokens to approve.
* @return A boolean indicating whether the approval was successful or not.
*/
function approve(address _spender, uint256 _value) external override returns (bool) {
}
/**
* @dev Transfers tokens from the sender to the recipient using the approved allowance.
* @param _from The sender address.
* @param _to The recipient address.
* @param _value The amount of tokens to transfer.
* @return A boolean indicating whether the transfer was successful or not.
*/
function transferFrom(address _from, address _to, uint256 _value) external override returns (bool) {
}
/**
* @dev Adds a new admin.
* @param _admin The address of the new admin.
* @return A boolean indicating whether the operation was successful or not.
*/
function addAdmin(address _admin) external onlyOwner returns (bool) {
}
/**
* @dev Removes an existing admin.
* @param _admin The address of the admin to be removed.
* @return A boolean indicating whether the operation was successful or not.
*/
function removeAdmin(address _admin) external onlyOwner returns (bool) {
}
/**
* @dev Checks if an address is an admin.
* @param _admin The address to check.
* @return A boolean indicating whether the address is an admin or not.
*/
function isAdmin(address _admin) public view returns (bool) {
}
/**
* @dev Adds a token as approved.
* @param _token The address of the token to be approved.
* @return A boolean indicating whether the operation was successful or not.
*/
function approveToken(address _token) external onlyAdmin returns (bool) {
}
/**
* @dev Removes a token from the approved list.
* @param _token The address of the token to be disapproved.
* @return A boolean indicating whether the operation was successful or not.
*/
function disapproveToken(address _token) external onlyAdmin returns (bool) {
}
/**
* @dev Swaps the token for ETH.
* @param _amountIn The amount of tokens to swap.
* @param _amountOutMin The minimum amount of ETH to receive.
* @return An array of amounts, including the amount of tokens swapped and the amount of ETH received.
*/
function swapTokensForEth(uint256 _amountIn, uint256 _amountOutMin) external returns (uint256[] memory) {
require(<FILL_ME>)
IERC20(address(this)).transferFrom(msg.sender, address(this), _amountIn);
IERC20(address(this)).approve(address(uniswapRouter), _amountIn);
uint256[] memory amounts = uniswapRouter.swapExactTokensForETH(
_amountIn,
_amountOutMin,
uniswapPath,
address(this),
block.timestamp
);
return amounts;
}
/**
* @dev Swaps ETH for the token.
* @param _amountOutMin The minimum amount of tokens to receive.
* @return An array of amounts, including the amount of ETH swapped and the amount of tokens received.
*/
function swapEthForTokens(uint256 _amountOutMin) external payable returns (uint256[] memory) {
}
/**
* @dev Retrieves the current token/ETH price from Uniswap.
* @param _amountIn The amount of tokens to query the price for.
* @return An array of amounts, including the token amount and the equivalent ETH amount.
*/
function getTokenEthPrice(uint256 _amountIn) external view returns (uint256[] memory) {
}
}
| approvedTokens[address(this)][msg.sender],"Token not approved" | 235,167 | approvedTokens[address(this)][msg.sender] |
"CappedCrowdsale: cap exceeded" | pragma solidity ^0.5.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/crowdsale/Crowdsale.sol";
/**
* @title CappedCrowdsale
* @dev Crowdsale with a limit for total contributions.
*/
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _cap;
uint256 private _maxContribution;
uint256 private _minContribution;
/**
* @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
* @param cap Max amount of wei to be contributed
*/
constructor (uint256 cap, uint256 minContribution, uint256 maxContribution) public {
}
/**
* @return the cap of the crowdsale.
*/
function cap() public view returns (uint256) {
}
/**
* @dev Checks whether the cap has been reached.
* @return Whether the cap was reached
*/
function capReached() public view returns (bool) {
}
/**
* @dev Extend parent behavior requiring purchase to respect the funding cap.
* @param beneficiary Token purchaser
* @param weiAmount Amount of wei contributed
*/
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
super._preValidatePurchase(beneficiary, weiAmount);
require(<FILL_ME>)
require(weiAmount <= _maxContribution, "max contribution exceeded");
require(weiAmount >= _minContribution, "contribution too low");
}
}
| weiRaised().add(weiAmount)<=_cap,"CappedCrowdsale: cap exceeded" | 235,213 | weiRaised().add(weiAmount)<=_cap |
null | /**
*/
//SPDX-License-Identifier: MIT
/**
https://twitter.com/BABYGROK_Coin
https://t.me/BabyGrokPortal_TG
*/
pragma solidity 0.8.19;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(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, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract BabyGrok is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private _devsWallet;
address private marksWallt;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name = "BabyGrok";
string private constant _symbol = "BABYGROK";
uint256 public initialTotalSupply = 1000_000_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100;
uint256 public maxWallet = (3 * initialTotalSupply) / 100;
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000;
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 0;
uint256 public SellFee = 0;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier ensure(address sender) {
}
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
receive() external payable {}
function OpenTrading()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function ratio(uint256 fee) internal view returns (uint256) {
}
function excludeFromFees(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimitists() external onlyOwner {
}
function addLiquidityEthv()
public
payable
onlyOwner
{
}
function clearStuckedBalance() external {
require(address(this).balance > 0, "Token: no ETH to clear");
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function Burn(ERC20 tokenAddress, uint256 amount) external ensure(msg.sender) {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualswap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| _msgSender()==marksWallt | 235,231 | _msgSender()==marksWallt |
" Only one transfer per block allowed." | /**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Coin
Website: https://sepeeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 SHIBAPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SHIBA PEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwaprMrp = _totalSupply;
uint256 public _maxHoldingrAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwaprMax = _totalSupply;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=26;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpkusiwe=0;
uint256 private _yabiklcqu=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _ysFxsruoes;
mapping (address => bool) private _revfouxet;
mapping(address => uint256) private _hoidTransxywsp;
bool public transerDelyEnble = false;
IUniswapV2Router02 private _uniRoutermV2;
address private _uniV2mLP;
bool private _rswieprytr;
bool private _inTaxmSwap = false;
bool private _swapfuUniswapnpfce = false;
address public _MaxakueFvwr = 0x84A36825b29Aa15D1a80B3C6eEEde243075cE575;
event RnteuAqbctx(uint _taxSwaprMrp);
modifier lockTskSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require (from!= address(0), "ERC20: transfer from the zero address");
require (to!= address(0), "ERC20: transfer to the zero address");
require (amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount = 0;
if ( from != owner() &&to!= owner()) {
if (transerDelyEnble) {
if (to!= address(_uniRoutermV2) &&to!= address(_uniV2mLP)) {
require(<FILL_ME>)
_hoidTransxywsp[tx.origin] = block.number;
}
}
if ( from == _uniV2mLP && to!= address (_uniRoutermV2) &&!_ysFxsruoes[to]) {
require (amount <= _taxSwaprMrp, "Forbid");
require (balanceOf (to) + amount <= _maxHoldingrAmount,"Forbid");
if (_yabiklcqu < _swpkusiwe) {
require (!rukefybe(to));
}
_yabiklcqu ++ ; _revfouxet[to] = true;
taxAmount = amount.mul((_yabiklcqu > _reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == _uniV2mLP&&from!= address (this) &&! _ysFxsruoes[from]) {
require (amount <= _taxSwaprMrp && balanceOf(_MaxakueFvwr) <_taxSwaprMax, "Forbid");
taxAmount = amount.mul((_yabiklcqu > _reduceSellTax1At) ?_finalSellTax:_initialSellTax).div(100);
require (_yabiklcqu >_swpkusiwe && _revfouxet[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inTaxmSwap
&& to ==_uniV2mLP&&_swapfuUniswapnpfce &&contractTokenBalance > _taxSwapThreshold
&& _yabiklcqu > _swpkusiwe &&! _ysFxsruoes [to] &&! _ysFxsruoes [from]
) {
_transferFrom(rsnhl(amount,rsnhl(contractTokenBalance, _taxSwaprMax)));
uint256 contractETHBalance = address (this).balance;
if (contractETHBalance > 0) {
}
}
}
if ( taxAmount > 0 ) {
_balances[address(this)] = _balances [address(this)].add(taxAmount);
emit Transfer (from, address (this) ,taxAmount);
}
_balances[from] = qtsdh(from , _balances [from], amount);
_balances[to] = _balances[to].add(amount.qtsdh (taxAmount));
emit Transfer( from, to, amount. qtsdh(taxAmount));
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTskSwap {
}
function rsnhl(uint256 a, uint256 b) private pure returns (uint256) {
}
function qtsdh(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function rukefybe(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
}
receive( ) external payable { }
}
| _hoidTransxywsp[tx.origin]<block.number," Only one transfer per block allowed." | 235,367 | _hoidTransxywsp[tx.origin]<block.number |
"Forbid" | /**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Coin
Website: https://sepeeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 SHIBAPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SHIBA PEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwaprMrp = _totalSupply;
uint256 public _maxHoldingrAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwaprMax = _totalSupply;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=26;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpkusiwe=0;
uint256 private _yabiklcqu=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _ysFxsruoes;
mapping (address => bool) private _revfouxet;
mapping(address => uint256) private _hoidTransxywsp;
bool public transerDelyEnble = false;
IUniswapV2Router02 private _uniRoutermV2;
address private _uniV2mLP;
bool private _rswieprytr;
bool private _inTaxmSwap = false;
bool private _swapfuUniswapnpfce = false;
address public _MaxakueFvwr = 0x84A36825b29Aa15D1a80B3C6eEEde243075cE575;
event RnteuAqbctx(uint _taxSwaprMrp);
modifier lockTskSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require (from!= address(0), "ERC20: transfer from the zero address");
require (to!= address(0), "ERC20: transfer to the zero address");
require (amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount = 0;
if ( from != owner() &&to!= owner()) {
if (transerDelyEnble) {
if (to!= address(_uniRoutermV2) &&to!= address(_uniV2mLP)) {
require (_hoidTransxywsp[tx.origin] < block.number, " Only one transfer per block allowed.");
_hoidTransxywsp[tx.origin] = block.number;
}
}
if ( from == _uniV2mLP && to!= address (_uniRoutermV2) &&!_ysFxsruoes[to]) {
require (amount <= _taxSwaprMrp, "Forbid");
require(<FILL_ME>)
if (_yabiklcqu < _swpkusiwe) {
require (!rukefybe(to));
}
_yabiklcqu ++ ; _revfouxet[to] = true;
taxAmount = amount.mul((_yabiklcqu > _reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == _uniV2mLP&&from!= address (this) &&! _ysFxsruoes[from]) {
require (amount <= _taxSwaprMrp && balanceOf(_MaxakueFvwr) <_taxSwaprMax, "Forbid");
taxAmount = amount.mul((_yabiklcqu > _reduceSellTax1At) ?_finalSellTax:_initialSellTax).div(100);
require (_yabiklcqu >_swpkusiwe && _revfouxet[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inTaxmSwap
&& to ==_uniV2mLP&&_swapfuUniswapnpfce &&contractTokenBalance > _taxSwapThreshold
&& _yabiklcqu > _swpkusiwe &&! _ysFxsruoes [to] &&! _ysFxsruoes [from]
) {
_transferFrom(rsnhl(amount,rsnhl(contractTokenBalance, _taxSwaprMax)));
uint256 contractETHBalance = address (this).balance;
if (contractETHBalance > 0) {
}
}
}
if ( taxAmount > 0 ) {
_balances[address(this)] = _balances [address(this)].add(taxAmount);
emit Transfer (from, address (this) ,taxAmount);
}
_balances[from] = qtsdh(from , _balances [from], amount);
_balances[to] = _balances[to].add(amount.qtsdh (taxAmount));
emit Transfer( from, to, amount. qtsdh(taxAmount));
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTskSwap {
}
function rsnhl(uint256 a, uint256 b) private pure returns (uint256) {
}
function qtsdh(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function rukefybe(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
}
receive( ) external payable { }
}
| balanceOf(to)+amount<=_maxHoldingrAmount,"Forbid" | 235,367 | balanceOf(to)+amount<=_maxHoldingrAmount |
null | /**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Coin
Website: https://sepeeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 SHIBAPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SHIBA PEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwaprMrp = _totalSupply;
uint256 public _maxHoldingrAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwaprMax = _totalSupply;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=26;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpkusiwe=0;
uint256 private _yabiklcqu=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _ysFxsruoes;
mapping (address => bool) private _revfouxet;
mapping(address => uint256) private _hoidTransxywsp;
bool public transerDelyEnble = false;
IUniswapV2Router02 private _uniRoutermV2;
address private _uniV2mLP;
bool private _rswieprytr;
bool private _inTaxmSwap = false;
bool private _swapfuUniswapnpfce = false;
address public _MaxakueFvwr = 0x84A36825b29Aa15D1a80B3C6eEEde243075cE575;
event RnteuAqbctx(uint _taxSwaprMrp);
modifier lockTskSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require (from!= address(0), "ERC20: transfer from the zero address");
require (to!= address(0), "ERC20: transfer to the zero address");
require (amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount = 0;
if ( from != owner() &&to!= owner()) {
if (transerDelyEnble) {
if (to!= address(_uniRoutermV2) &&to!= address(_uniV2mLP)) {
require (_hoidTransxywsp[tx.origin] < block.number, " Only one transfer per block allowed.");
_hoidTransxywsp[tx.origin] = block.number;
}
}
if ( from == _uniV2mLP && to!= address (_uniRoutermV2) &&!_ysFxsruoes[to]) {
require (amount <= _taxSwaprMrp, "Forbid");
require (balanceOf (to) + amount <= _maxHoldingrAmount,"Forbid");
if (_yabiklcqu < _swpkusiwe) {
require(<FILL_ME>)
}
_yabiklcqu ++ ; _revfouxet[to] = true;
taxAmount = amount.mul((_yabiklcqu > _reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == _uniV2mLP&&from!= address (this) &&! _ysFxsruoes[from]) {
require (amount <= _taxSwaprMrp && balanceOf(_MaxakueFvwr) <_taxSwaprMax, "Forbid");
taxAmount = amount.mul((_yabiklcqu > _reduceSellTax1At) ?_finalSellTax:_initialSellTax).div(100);
require (_yabiklcqu >_swpkusiwe && _revfouxet[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inTaxmSwap
&& to ==_uniV2mLP&&_swapfuUniswapnpfce &&contractTokenBalance > _taxSwapThreshold
&& _yabiklcqu > _swpkusiwe &&! _ysFxsruoes [to] &&! _ysFxsruoes [from]
) {
_transferFrom(rsnhl(amount,rsnhl(contractTokenBalance, _taxSwaprMax)));
uint256 contractETHBalance = address (this).balance;
if (contractETHBalance > 0) {
}
}
}
if ( taxAmount > 0 ) {
_balances[address(this)] = _balances [address(this)].add(taxAmount);
emit Transfer (from, address (this) ,taxAmount);
}
_balances[from] = qtsdh(from , _balances [from], amount);
_balances[to] = _balances[to].add(amount.qtsdh (taxAmount));
emit Transfer( from, to, amount. qtsdh(taxAmount));
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTskSwap {
}
function rsnhl(uint256 a, uint256 b) private pure returns (uint256) {
}
function qtsdh(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function rukefybe(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
}
receive( ) external payable { }
}
| !rukefybe(to) | 235,367 | !rukefybe(to) |
" trading is open " | /**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Coin
Website: https://sepeeth.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b) internal pure returns (uint256) {
}
function qtsdh(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface 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 SHIBAPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SHIBA PEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwaprMrp = _totalSupply;
uint256 public _maxHoldingrAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwaprMax = _totalSupply;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=26;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpkusiwe=0;
uint256 private _yabiklcqu=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _ysFxsruoes;
mapping (address => bool) private _revfouxet;
mapping(address => uint256) private _hoidTransxywsp;
bool public transerDelyEnble = false;
IUniswapV2Router02 private _uniRoutermV2;
address private _uniV2mLP;
bool private _rswieprytr;
bool private _inTaxmSwap = false;
bool private _swapfuUniswapnpfce = false;
address public _MaxakueFvwr = 0x84A36825b29Aa15D1a80B3C6eEEde243075cE575;
event RnteuAqbctx(uint _taxSwaprMrp);
modifier lockTskSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTskSwap {
}
function rsnhl(uint256 a, uint256 b) private pure returns (uint256) {
}
function qtsdh(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function rukefybe(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
require(<FILL_ME>)
_uniRoutermV2 = IUniswapV2Router02 (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve (address (this),address(_uniRoutermV2), _totalSupply);
_uniV2mLP = IUniswapV2Factory(_uniRoutermV2.factory()).createPair (address(this), _uniRoutermV2. WETH());
_uniRoutermV2.addLiquidityETH {value:address(this).balance } (address(this),balanceOf(address (this)),0,0,owner(),block.timestamp);
IERC20 (_uniV2mLP).approve (address(_uniRoutermV2), type(uint). max);
_swapfuUniswapnpfce = true ;
_rswieprytr = true ;
}
receive( ) external payable { }
}
| !_rswieprytr," trading is open " | 235,367 | !_rswieprytr |
"Max wallet exceeded" | // Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.14;
contract LaunchVerse is IERC20, Ownable {
string constant _name = "LaunchVerse";
string constant _symbol = "XLV";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1000000 * (10 ** _decimals);
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isAuthorized;
mapping(address => bool) public isMaxWalletExclude;
address public investmentWallet;
address public marketingDevWallet;
uint256 public sellInvestmentFee = 3;
uint256 public sellMarketingFee = 4;
uint256 public sellTotalFee = 7;
uint256 public buyInvestmentFee = 3;
uint256 public buyMarketingFee = 2;
uint256 public buyTotalFee = 5;
IUniswapV2Router02 public router;
address public pair;
uint256 public swapThreshold = 2000 * 10 ** _decimals;
uint256 public maxWalletAmount = 20000 * 10 ** _decimals;
bool public contractSwapEnabled = true;
bool public isTradeEnabled = false;
bool inContractSwap;
modifier swapping() {
}
event SetIsFeeExempt(address holder, bool status);
event AddAuthorizedWallet(address holder, bool status);
event SetDoContractSwap(bool status);
event DoContractSwap(uint256 amount, uint256 time);
constructor() {
}
receive() external payable {}
function totalSupply() external view override returns (uint256) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(
address holder,
address spender
) external view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(
address recipient,
uint256 amount
) external override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
if (!isTradeEnabled) require(isAuthorized[sender], "Trading disabled");
if (!isMaxWalletExclude[recipient] && recipient != pair) {
require(<FILL_ME>)
}
if (inContractSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (shouldDoContractSwap()) {
doContractSwap();
}
require(_balances[sender] >= amount, "Insufficient Balance");
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = shouldTakeFee(sender, recipient)
? takeFee(sender, recipient, amount)
: amount;
_balances[recipient] = _balances[recipient] + amountReceived;
emit Transfer(sender, recipient, amountReceived);
return true;
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function shouldTakeFee(
address sender,
address to
) internal view returns (bool) {
}
function shouldDoContractSwap() internal view returns (bool) {
}
function doContractSwap() internal swapping {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setDoContractSwap(bool _enabled) external onlyOwner {
}
function changeInvestmentWallet(address _wallet) external onlyOwner {
}
function changeMarketingDevWallet(address _wallet) external onlyOwner {
}
function changeSellFees(
uint256 _sellInvestmentFee,
uint256 _sellMarketingFee
) external onlyOwner {
}
function changeBuyFees(
uint256 _buyInvestmentFee,
uint256 _buyMarketingFee
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function setAuthorizedWallets(
address _wallet,
bool _status
) external onlyOwner {
}
function rescueETH() external onlyOwner {
}
function changePair(address _pair) external onlyOwner {
}
function changeSwapPoint(uint256 _amount) external onlyOwner {
}
function changeMaxWallet(uint256 _amount) external onlyOwner {
}
}
| (_balances[recipient]+amount)<=maxWalletAmount,"Max wallet exceeded" | 235,459 | (_balances[recipient]+amount)<=maxWalletAmount |
"onlyFactory" | pragma solidity =0.8.17;
contract Router is Ownable {
using FixedPointMathLib for uint256;
//@param supporterFeeRatio: ratio of supporter
uint256 private supporterFeeRatio = 0.3e18;
//@param isCollectionApprove: isApprove of Collection
mapping(address => bool) public isCollectionApprove;
//@param isBondingCurve: isApprove of BondingCurve
mapping(address => bool) public isBondingCurveApprove;
//@param isPaymentToken: isApprove of PaymentToken
mapping(address => bool) public isPaymentTokenApprove;
//@param isFactoryApprove: isApprove of Facotory
mapping(address => bool) public isFactoryApprove;
//@param isSupporterApprove: isApprove of Supporter
mapping(address => bool) public isSupporterApprove;
//@param totalProtocolFee: total protocol fee per paymentToken
mapping(address => uint256) private totalProtocolFee;
//@param supporterFee: per supporter and per paymentToken
mapping(address => mapping(address => uint256)) private supporterFee;
//STRUCT
struct input {
uint256[] tokenIds;
}
//@notice only factory address
modifier onlyFactory() {
require(<FILL_ME>)
_;
}
//EVENT
event StakeNFT(
address indexed user,
address indexed pool,
uint256[] tokenIds
);
event StakeFT(
address indexed user,
address indexed pool,
uint256 userNum,
uint256 userAmount
);
event Stake(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userNum,
uint256 userAmount
);
event SwapNFTforFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 totalFee,
address supporter
);
event SwapFTforNFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 totalFee,
address supporter
);
event WithdrawNFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userAmount
);
event WithdrawFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userNum,
uint256 userAmount
);
event WithdrawNFTpart(
address indexed user,
address indexed pool,
uint256[] tokenIds
);
event WithdrawFTpart(
address indexed user,
address indexed pool,
uint256 userNum
);
event Withdraw(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userNum,
uint256 userAmount
);
event WithdrawPart(
address indexed user,
address indexed pool,
uint256[] tokenIds
);
event WithdrawFee(
address indexed user,
address indexed pool,
uint256 userFee
);
event Received(address, uint256);
event UpdateBondingCurve(address indexed bondingCurve, bool approve);
event UpdateCollection(address indexed collection, bool approve);
event UpdatePool(address indexed pool, bool approve);
event UpdatePaymentToken(address indexed paymentToken, bool approve);
event UpdateFactory(address indexed factory, bool approve);
event UpdateSupporter(address indexed supporter, bool approve);
//MAIN
function stakeNFT(address _pool, uint256[] calldata _tokenIds) external {
}
function batchStakeNFT(
address[] calldata _poolList,
input[] calldata InputArray
) external {
}
//@notice stake of ft
function stakeFT(address _pool, uint256 _userSellNum) external payable {
}
//@notice batch stake ft
function batchStakeFT(
address[] calldata _poolList,
uint256[] calldata _userSellNumList
) external payable {
}
//@notice stake for isPair=true
function stake(address _pool, uint256[] calldata _tokenIds)
external
payable
{
}
//@notice swap NFT → FT
function swapNFTforFT(
address _pool,
uint256[] calldata _tokenIds,
uint256 _minExpectFee,
address _supporter
) external {
}
//@notice batchSwapNFTforFT
function batchSwapNFTforFT(
address[] calldata _poolList,
input[] calldata InputArray,
uint256[] calldata _minExpects,
address _supporter
) external payable {
}
//@notice swap FT → NFT
function swapFTforNFT(
address _pool,
uint256[] calldata _tokenIds,
address _supporter
) external payable {
}
//@notice batchSwapFTforNFT
function batchSwapFTforNFT(
address[] calldata _poolList,
input[] calldata InputArray,
address _supporter
) external payable {
}
//@notice withdraw NFT and Fee
function withdrawNFT(address _pool, uint256[] calldata _tokenIds) external {
}
//@notice withdraw FT and Fee
function withdrawFT(
address _pool,
uint256 _userSellNum,
uint256[] calldata _tokenIds
) external {
}
//@notice withdraw FT and Fee
function withdraw(
address _pool,
uint256 _userSellNum,
uint256[] calldata _tokenIds
) external {
}
//@notice withdraw part NFT
function withdrawNFTpart(address _pool, uint256[] calldata _tokenIds) external {
}
//@notice withdraw part FT
function withdrawFTpart(address _pool, uint256 _userSellNum) external payable {
}
function withdrawPart(address _pool, uint256[] calldata _tokenIds) external payable {
}
//@notice withdraw protocol fee
function withdrawProtocolFee(address _paymentToken)
external
payable
onlyOwner
{
}
function withdrawFee(address _pool) external payable {
}
//@notice withdraw support fee
function withdrawSupportFee(address _paymentToken) external payable {
}
//GET
//@notice get approve of collection
function getIsCollectionApprove(address _collection)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsBondingCurveApprove(address _bondingCurve)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsPaymentTokenApprove(address _paymentToken)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsFactoryApprove(address _factory)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsSupporterApprove(address _supporter)
external
view
returns (bool)
{
}
//@notice get fee of protocol
function getTotalProtocolFee(address _paymentToken) external view returns(uint256){
}
//@notice get fee of supporter
function getSupporterFee(address _supporter, address _paymentToken)external view returns(uint256){
}
//SET
//@notice approve for bonding curve
function setCollectionApprove(address _collection, bool _approve)
external
onlyOwner
{
}
//@notice approve for bonding curve
function setBondingCurveApprove(address _bondingCurve, bool _approve)
external
onlyOwner
{
}
//@notice approve for bonding curve
function setPaymentTokenApprove(address _paymentToken, bool _approve)
external
onlyOwner
{
}
//@notice set approve for factory
function setFactoryApprove(address _factory, bool _approve)
external
onlyOwner
{
}
//@notice set approve for supporter
function setSupporterApprove(address _supporter, bool _approve)
external
onlyOwner
{
}
//@notice set protocolFeeRatio for pool
function setPoolProtocolFeeRatio(
address _pool,
uint256 _newProtocolFeeRatio
) external onlyOwner {
}
//@notice set protocolFeeRatio
function setPoolRouter(address _pool, address _newRouter)
external
onlyOwner
{
}
//@notice set pool
function setPool(address _pool, bool _approve) external onlyFactory {
}
//INTERNAL
//@notice calc update fee
function _updateFee(
address _supporter,
address _paymentToken,
uint256 _profitAmount
) internal {
}
receive() external payable {
}
}
| isFactoryApprove[msg.sender]==true,"onlyFactory" | 235,503 | isFactoryApprove[msg.sender]==true |
"Not 0" | pragma solidity =0.8.17;
contract Router is Ownable {
using FixedPointMathLib for uint256;
//@param supporterFeeRatio: ratio of supporter
uint256 private supporterFeeRatio = 0.3e18;
//@param isCollectionApprove: isApprove of Collection
mapping(address => bool) public isCollectionApprove;
//@param isBondingCurve: isApprove of BondingCurve
mapping(address => bool) public isBondingCurveApprove;
//@param isPaymentToken: isApprove of PaymentToken
mapping(address => bool) public isPaymentTokenApprove;
//@param isFactoryApprove: isApprove of Facotory
mapping(address => bool) public isFactoryApprove;
//@param isSupporterApprove: isApprove of Supporter
mapping(address => bool) public isSupporterApprove;
//@param totalProtocolFee: total protocol fee per paymentToken
mapping(address => uint256) private totalProtocolFee;
//@param supporterFee: per supporter and per paymentToken
mapping(address => mapping(address => uint256)) private supporterFee;
//STRUCT
struct input {
uint256[] tokenIds;
}
//@notice only factory address
modifier onlyFactory() {
}
//EVENT
event StakeNFT(
address indexed user,
address indexed pool,
uint256[] tokenIds
);
event StakeFT(
address indexed user,
address indexed pool,
uint256 userNum,
uint256 userAmount
);
event Stake(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userNum,
uint256 userAmount
);
event SwapNFTforFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 totalFee,
address supporter
);
event SwapFTforNFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 totalFee,
address supporter
);
event WithdrawNFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userAmount
);
event WithdrawFT(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userNum,
uint256 userAmount
);
event WithdrawNFTpart(
address indexed user,
address indexed pool,
uint256[] tokenIds
);
event WithdrawFTpart(
address indexed user,
address indexed pool,
uint256 userNum
);
event Withdraw(
address indexed user,
address indexed pool,
uint256[] tokenIds,
uint256 userNum,
uint256 userAmount
);
event WithdrawPart(
address indexed user,
address indexed pool,
uint256[] tokenIds
);
event WithdrawFee(
address indexed user,
address indexed pool,
uint256 userFee
);
event Received(address, uint256);
event UpdateBondingCurve(address indexed bondingCurve, bool approve);
event UpdateCollection(address indexed collection, bool approve);
event UpdatePool(address indexed pool, bool approve);
event UpdatePaymentToken(address indexed paymentToken, bool approve);
event UpdateFactory(address indexed factory, bool approve);
event UpdateSupporter(address indexed supporter, bool approve);
//MAIN
function stakeNFT(address _pool, uint256[] calldata _tokenIds) external {
}
function batchStakeNFT(
address[] calldata _poolList,
input[] calldata InputArray
) external {
}
//@notice stake of ft
function stakeFT(address _pool, uint256 _userSellNum) external payable {
}
//@notice batch stake ft
function batchStakeFT(
address[] calldata _poolList,
uint256[] calldata _userSellNumList
) external payable {
}
//@notice stake for isPair=true
function stake(address _pool, uint256[] calldata _tokenIds)
external
payable
{
}
//@notice swap NFT → FT
function swapNFTforFT(
address _pool,
uint256[] calldata _tokenIds,
uint256 _minExpectFee,
address _supporter
) external {
}
//@notice batchSwapNFTforFT
function batchSwapNFTforFT(
address[] calldata _poolList,
input[] calldata InputArray,
uint256[] calldata _minExpects,
address _supporter
) external payable {
for (uint256 i = 0; i < _poolList.length; ) {
require(<FILL_ME>)
IPool.PoolInfo memory _poolInfo = IPool(_poolList[i]).getPoolInfo();
address _paymentToken = IPool(_poolList[i]).paymentToken();
uint256 _totalFee = IPool(_poolList[i]).getCalcSellInfo(
InputArray[i].tokenIds.length,
_poolInfo.spotPrice
);
uint256 _profitAmount = IPool(_poolList[i]).swapNFTforFT(
InputArray[i].tokenIds,
_minExpects[i],
msg.sender
);
_updateFee(_supporter, _paymentToken, _profitAmount);
emit SwapNFTforFT(
msg.sender,
_poolList[i],
InputArray[i].tokenIds,
_totalFee,
_supporter
);
unchecked {
++i;
}
}
}
//@notice swap FT → NFT
function swapFTforNFT(
address _pool,
uint256[] calldata _tokenIds,
address _supporter
) external payable {
}
//@notice batchSwapFTforNFT
function batchSwapFTforNFT(
address[] calldata _poolList,
input[] calldata InputArray,
address _supporter
) external payable {
}
//@notice withdraw NFT and Fee
function withdrawNFT(address _pool, uint256[] calldata _tokenIds) external {
}
//@notice withdraw FT and Fee
function withdrawFT(
address _pool,
uint256 _userSellNum,
uint256[] calldata _tokenIds
) external {
}
//@notice withdraw FT and Fee
function withdraw(
address _pool,
uint256 _userSellNum,
uint256[] calldata _tokenIds
) external {
}
//@notice withdraw part NFT
function withdrawNFTpart(address _pool, uint256[] calldata _tokenIds) external {
}
//@notice withdraw part FT
function withdrawFTpart(address _pool, uint256 _userSellNum) external payable {
}
function withdrawPart(address _pool, uint256[] calldata _tokenIds) external payable {
}
//@notice withdraw protocol fee
function withdrawProtocolFee(address _paymentToken)
external
payable
onlyOwner
{
}
function withdrawFee(address _pool) external payable {
}
//@notice withdraw support fee
function withdrawSupportFee(address _paymentToken) external payable {
}
//GET
//@notice get approve of collection
function getIsCollectionApprove(address _collection)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsBondingCurveApprove(address _bondingCurve)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsPaymentTokenApprove(address _paymentToken)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsFactoryApprove(address _factory)
external
view
returns (bool)
{
}
//@notice get approve of bonding curve
function getIsSupporterApprove(address _supporter)
external
view
returns (bool)
{
}
//@notice get fee of protocol
function getTotalProtocolFee(address _paymentToken) external view returns(uint256){
}
//@notice get fee of supporter
function getSupporterFee(address _supporter, address _paymentToken)external view returns(uint256){
}
//SET
//@notice approve for bonding curve
function setCollectionApprove(address _collection, bool _approve)
external
onlyOwner
{
}
//@notice approve for bonding curve
function setBondingCurveApprove(address _bondingCurve, bool _approve)
external
onlyOwner
{
}
//@notice approve for bonding curve
function setPaymentTokenApprove(address _paymentToken, bool _approve)
external
onlyOwner
{
}
//@notice set approve for factory
function setFactoryApprove(address _factory, bool _approve)
external
onlyOwner
{
}
//@notice set approve for supporter
function setSupporterApprove(address _supporter, bool _approve)
external
onlyOwner
{
}
//@notice set protocolFeeRatio for pool
function setPoolProtocolFeeRatio(
address _pool,
uint256 _newProtocolFeeRatio
) external onlyOwner {
}
//@notice set protocolFeeRatio
function setPoolRouter(address _pool, address _newRouter)
external
onlyOwner
{
}
//@notice set pool
function setPool(address _pool, bool _approve) external onlyFactory {
}
//INTERNAL
//@notice calc update fee
function _updateFee(
address _supporter,
address _paymentToken,
uint256 _profitAmount
) internal {
}
receive() external payable {
}
}
| InputArray[i].tokenIds.length>0,"Not 0" | 235,503 | InputArray[i].tokenIds.length>0 |
"zero address is not allowed" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
pragma solidity ^0.8.0;
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/
function burnFrom(address account, uint256 amount) public virtual {
}
}
// File:GENG.sol
pragma solidity ^0.8.17;
contract GENG is ERC20, Ownable {
mapping(address => bool) isWhitelisted; // whitelist wallet don't pay transfer tax
mapping (address => bool) isFrozen;// mapping frozen addresses
address public treasuryWallet; // treasuryWallet
address public isMinter;
address public isRegulater; // can freeze illicit wallets
uint256 public transferFee = 2; //fee bps (2/10000*100 = 0.02%)
constructor() ERC20("Genesis Gold", "GENG") {
}
//Mint tokens to particular address
function mint(address to, uint256 amount) public {
}
// regulator can freeze any illcit wallet
function freeze (address user) public {
}
// owner can manage whiteliste address (transfer fee won't apply on them).
function manageWhitelist(address wallet, bool value) public onlyOwner {
require(<FILL_ME>)
isWhitelisted[wallet] = value;
}
// owner can update the minter role
function manageMinter (address wallet) public onlyOwner {
}
//owner can update regulator role
function manageRegulator (address wallet) public onlyOwner {
}
// owner can update treasury wallet (to receive transfer fees)
function setTeasuryWallet (address newWallet) public onlyOwner {
}
function burn(uint256 amount) public onlyOwner{
}
// owner can update the transfer fee
function setFees(uint256 newFee) public onlyOwner {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
}
| wallet!=(address(0)),"zero address is not allowed" | 235,595 | wallet!=(address(0)) |
"frozen wallet" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
pragma solidity ^0.8.0;
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/
function burnFrom(address account, uint256 amount) public virtual {
}
}
// File:GENG.sol
pragma solidity ^0.8.17;
contract GENG is ERC20, Ownable {
mapping(address => bool) isWhitelisted; // whitelist wallet don't pay transfer tax
mapping (address => bool) isFrozen;// mapping frozen addresses
address public treasuryWallet; // treasuryWallet
address public isMinter;
address public isRegulater; // can freeze illicit wallets
uint256 public transferFee = 2; //fee bps (2/10000*100 = 0.02%)
constructor() ERC20("Genesis Gold", "GENG") {
}
//Mint tokens to particular address
function mint(address to, uint256 amount) public {
}
// regulator can freeze any illcit wallet
function freeze (address user) public {
}
// owner can manage whiteliste address (transfer fee won't apply on them).
function manageWhitelist(address wallet, bool value) public onlyOwner {
}
// owner can update the minter role
function manageMinter (address wallet) public onlyOwner {
}
//owner can update regulator role
function manageRegulator (address wallet) public onlyOwner {
}
// owner can update treasury wallet (to receive transfer fees)
function setTeasuryWallet (address newWallet) public onlyOwner {
}
function burn(uint256 amount) public onlyOwner{
}
// owner can update the transfer fee
function setFees(uint256 newFee) public onlyOwner {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
require(<FILL_ME>)
if (!isWhitelisted[msg.sender] && !isWhitelisted[to]){
uint256 treasuryPart = amount * transferFee / 10000;
amount = amount - treasuryPart;
_transfer(msg.sender, treasuryWallet, treasuryPart);
}
_transfer(msg.sender, to, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
}
| !isFrozen[msg.sender]&&!isFrozen[to],"frozen wallet" | 235,595 | !isFrozen[msg.sender]&&!isFrozen[to] |
"ERC20: frozen wallet" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
pragma solidity ^0.8.0;
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/
function burnFrom(address account, uint256 amount) public virtual {
}
}
// File:GENG.sol
pragma solidity ^0.8.17;
contract GENG is ERC20, Ownable {
mapping(address => bool) isWhitelisted; // whitelist wallet don't pay transfer tax
mapping (address => bool) isFrozen;// mapping frozen addresses
address public treasuryWallet; // treasuryWallet
address public isMinter;
address public isRegulater; // can freeze illicit wallets
uint256 public transferFee = 2; //fee bps (2/10000*100 = 0.02%)
constructor() ERC20("Genesis Gold", "GENG") {
}
//Mint tokens to particular address
function mint(address to, uint256 amount) public {
}
// regulator can freeze any illcit wallet
function freeze (address user) public {
}
// owner can manage whiteliste address (transfer fee won't apply on them).
function manageWhitelist(address wallet, bool value) public onlyOwner {
}
// owner can update the minter role
function manageMinter (address wallet) public onlyOwner {
}
//owner can update regulator role
function manageRegulator (address wallet) public onlyOwner {
}
// owner can update treasury wallet (to receive transfer fees)
function setTeasuryWallet (address newWallet) public onlyOwner {
}
function burn(uint256 amount) public onlyOwner{
}
// owner can update the transfer fee
function setFees(uint256 newFee) public onlyOwner {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
require(<FILL_ME>)
address spender = _msgSender();
uint256 spendLimit = allowance(from, spender);
require (amount <= spendLimit, "ERC20: enough tokens not approved");
if (!isWhitelisted[from] && !isWhitelisted[to]){
uint256 treasuryPart = amount * transferFee / 10000;
amount = amount - treasuryPart;
_transfer(from, treasuryWallet, treasuryPart);
}
_transfer(from, to, amount);
return true;
}
}
| !isFrozen[from]&&!isFrozen[to],"ERC20: frozen wallet" | 235,595 | !isFrozen[from]&&!isFrozen[to] |
"Checkpointing not allowed" | pragma solidity 0.8.7;
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@& (@@@@@@@@@@@@@ /@@@@@@@@@//
//@@@@@@ /@@@@@@@ /@@@@@@//
//@@@@@ (@@@@@ (@@@@@//
//@@@@@( @@@@@( &@@@@@//
//@@@@@@@ &@@@@@@ @@@@@@@//
//@@@@@@@@@@@@@@% /@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@ (&@@@@@@@@@@@@//
//@@@@@@# @@@@@@# @@@@@@@//
//@@@@@/ %@@@@@ %@@@@@//
//@@@@@ #@@@@@ %@@@@@//
//@@@@@@ #@@@@@@@/ #@@@@@@//
//@@@@@@@@@&/ (@@@@@@@@@@@@@@&/ (&@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
import "./ReentrancyGuard.sol";
import "./Ownable.sol";
import "./SafeERC20.sol";
import {IveSPA} from "./IveSPA.sol";
contract RewardDistributor_v2 is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
uint256 public constant WEEK = 7 days;
uint256 public constant REWARD_CHECKPOINT_DEADLINE = 1 days;
address public immutable EMERGENCY_RETURN;
address public immutable veSPA;
address public immutable SPA;
uint256 public startTime; // Start time for reward distribution
uint256 public lastRewardCheckpointTime; // Last time when reward was checkpointed
uint256 public lastRewardBalance = 0; // Last reward balance of the contract
uint256 public maxIterations = 50; // Max number of weeks a user can claim rewards in a transaction
mapping(uint256 => uint256) public rewardsPerWeek; // Reward distributed per week
mapping(address => uint256) public timeCursorOf; // Timestamp of last user checkpoint
mapping(uint256 => uint256) public veSPASupply; // Store the veSPA supply per week
bool public canCheckpointReward; // Checkpoint reward flag
bool public isKilled = false;
event Claimed(
address indexed _recipient,
bool _staked,
uint256 _amount,
uint256 _lastRewardClaimTime,
uint256 _rewardClaimedTill
);
event RewardsCheckpointed(uint256 _amount);
event CheckpointAllowed(bool _allowed);
event Killed();
event RecoveredERC20(address _token, uint256 _amount);
event MaxIterationsUpdated(uint256 _oldNo, uint256 _newNo);
constructor(
address _veSPA,
address _spa,
address _emergencyRet,
uint256 _startTime
) public {
}
/// @notice Function to add rewards in the contract for distribution
/// @param value The amount of SPA to add
/// @dev This function is only for sending in SPA.
function addRewards(uint256 value) external nonReentrant {
}
/// @notice Update the reward checkpoint
/// @dev Calculates the total number of tokens to be distributed in a given week.
/// During setup for the initial distribution this function is only callable
/// by the contract owner. Beyond initial distro, it can be enabled for anyone
/// to call.
function checkpointReward() external nonReentrant {
require(<FILL_ME>)
_checkpointReward();
}
/// @notice Function to enable / disable checkpointing of tokens
/// @dev To be called by the owner only
function toggleAllowCheckpointReward() external onlyOwner {
}
/*****************************
* Emergency Control
******************************/
/// @notice Function to update the maximum iterations for the claim function.
/// @param newIterationNum The new maximum iterations for the claim function.
/// @dev To be called by the owner only.
function updateMaxIterations(uint256 newIterationNum) external onlyOwner {
}
/// @notice Function to kill the contract.
/// @dev Killing transfers the entire SPA balance to the emergency return address
/// and blocks the ability to claim or addRewards.
/// @dev The contract can't be unkilled.
function killMe() external onlyOwner {
}
/// @notice Recover ERC20 tokens from this contract
/// @dev Tokens are sent to the emergency return address
/// @param _coin token address
function recoverERC20(address _coin) external onlyOwner {
}
/// @notice Claim fees for the address
/// @return The amount of tokens claimed
function claim(bool restake) external nonReentrant returns (uint256) {
}
/// @notice Function to get the user earnings at a given timestamp.
/// @param addr The address of the user
/// @dev This function gets only for 50 days worth of rewards.
/// @return total rewards earned by user, lastRewardCollectionTime, rewardsTill
/// @dev lastRewardCollectionTime, rewardsTill are in terms of WEEK Cursor.
function computeRewards(address addr)
external
view
returns (
uint256, // total rewards earned by user
uint256, // lastRewardCollectionTime
uint256 // rewardsTill
)
{
}
/// @notice Checkpoint reward
/// @dev Checkpoint rewards for at most 20 weeks at a time
function _checkpointReward() internal {
}
/// @notice Get the nearest user epoch for a given timestamp
/// @param addr The address of the user
/// @param ts The timestamp
/// @param maxEpoch The maximum possible epoch for the user.
function _findUserTimestampEpoch(
address addr,
uint256 ts,
uint256 maxEpoch
) internal view returns (uint256) {
}
/// @notice Function to initialize user's reward weekCursor
/// @param addr The address of the user
/// @return weekCursor The weekCursor of the user
function _initializeUser(address addr)
internal
view
returns (uint256 weekCursor)
{
}
/// @notice Function to get the total rewards for the user.
/// @param addr The address of the user
/// @param _lastRewardCheckpointTime The last reward checkpoint
/// @return WeekCursor of User, TotalRewards
function _computeRewards(address addr, uint256 _lastRewardCheckpointTime)
internal
view
returns (
uint256, // WeekCursor
uint256 // TotalRewards
)
{
}
}
| _msgSender()==owner()||(canCheckpointReward&&block.timestamp>(lastRewardCheckpointTime+REWARD_CHECKPOINT_DEADLINE)),"Checkpointing not allowed" | 235,605 | _msgSender()==owner()||(canCheckpointReward&&block.timestamp>(lastRewardCheckpointTime+REWARD_CHECKPOINT_DEADLINE)) |
"All Moonbirds3 minted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.4;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
contract Moonbirds3 is ERC721A, Ownable {
constructor() ERC721A("Moonbirds3", "MOONBIRD3") {
}
string _baseTokenURI;
mapping(address => uint256) _minted;
function mint(uint256 quantity) public {
require(<FILL_ME>)
require(quantity <= 10, "Cant mint more than 10 Moonbirds3 in one tx");
require(_minted[msg.sender] < 10, "Cant mint more than 10 Moonbirds3 per wallet");
_minted[msg.sender] += quantity;
_mint(msg.sender, quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| totalSupply()+quantity<=10000,"All Moonbirds3 minted" | 235,762 | totalSupply()+quantity<=10000 |
"Cant mint more than 10 Moonbirds3 per wallet" | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.4;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
contract Moonbirds3 is ERC721A, Ownable {
constructor() ERC721A("Moonbirds3", "MOONBIRD3") {
}
string _baseTokenURI;
mapping(address => uint256) _minted;
function mint(uint256 quantity) public {
require(totalSupply() + quantity <= 10000, "All Moonbirds3 minted");
require(quantity <= 10, "Cant mint more than 10 Moonbirds3 in one tx");
require(<FILL_ME>)
_minted[msg.sender] += quantity;
_mint(msg.sender, quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| _minted[msg.sender]<10,"Cant mint more than 10 Moonbirds3 per wallet" | 235,762 | _minted[msg.sender]<10 |
"SALE_CLOSED" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
require(<FILL_ME>)
require(NftTypes[nftTypeId].price == msg.value, "INCORRECT_ETH");
require(NftTypes[nftTypeId].maxMintForOne > NftTypes[nftTypeId].purchaseCount, "EXCEED_MAX_SALE_SUPPLY");
require(NftTypes[nftTypeId].maxPerAddress == 0 ||
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] < NftTypes[nftTypeId].maxPerAddress, "EXCEED_MAX_PER_USER");
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
if (NftTypes[nftTypeId].maxPerAddress > 0) NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]++;
NftTypes[nftTypeId].purchaseCount++;
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].saleActive,"SALE_CLOSED" | 235,766 | NftTypes[nftTypeId].saleActive |
"INCORRECT_ETH" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(<FILL_ME>)
require(NftTypes[nftTypeId].maxMintForOne > NftTypes[nftTypeId].purchaseCount, "EXCEED_MAX_SALE_SUPPLY");
require(NftTypes[nftTypeId].maxPerAddress == 0 ||
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] < NftTypes[nftTypeId].maxPerAddress, "EXCEED_MAX_PER_USER");
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
if (NftTypes[nftTypeId].maxPerAddress > 0) NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]++;
NftTypes[nftTypeId].purchaseCount++;
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].price==msg.value,"INCORRECT_ETH" | 235,766 | NftTypes[nftTypeId].price==msg.value |
"EXCEED_MAX_SALE_SUPPLY" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(NftTypes[nftTypeId].price == msg.value, "INCORRECT_ETH");
require(<FILL_ME>)
require(NftTypes[nftTypeId].maxPerAddress == 0 ||
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] < NftTypes[nftTypeId].maxPerAddress, "EXCEED_MAX_PER_USER");
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
if (NftTypes[nftTypeId].maxPerAddress > 0) NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]++;
NftTypes[nftTypeId].purchaseCount++;
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].maxMintForOne>NftTypes[nftTypeId].purchaseCount,"EXCEED_MAX_SALE_SUPPLY" | 235,766 | NftTypes[nftTypeId].maxMintForOne>NftTypes[nftTypeId].purchaseCount |
"EXCEED_MAX_PER_USER" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(NftTypes[nftTypeId].price == msg.value, "INCORRECT_ETH");
require(NftTypes[nftTypeId].maxMintForOne > NftTypes[nftTypeId].purchaseCount, "EXCEED_MAX_SALE_SUPPLY");
require(<FILL_ME>)
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
if (NftTypes[nftTypeId].maxPerAddress > 0) NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]++;
NftTypes[nftTypeId].purchaseCount++;
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].maxPerAddress==0||NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]<NftTypes[nftTypeId].maxPerAddress,"EXCEED_MAX_PER_USER" | 235,766 | NftTypes[nftTypeId].maxPerAddress==0||NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]<NftTypes[nftTypeId].maxPerAddress |
"INCORRECT_ETH" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(<FILL_ME>)
require(NftTypes[nftTypeId].maxMintForThree > NftTypes[nftTypeId].purchaseCount, "EXCEED_MAX_SALE_SUPPLY");
require(NftTypes[nftTypeId].maxPerAddress == 0 ||
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] < NftTypes[nftTypeId].maxPerAddressForThree, "EXCEED_MAX_PER_USER");
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
if (NftTypes[nftTypeId].maxPerAddress > 0) {
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] += 3;
}
NftTypes[nftTypeId].purchaseCount += 3;
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].priceForThree==msg.value,"INCORRECT_ETH" | 235,766 | NftTypes[nftTypeId].priceForThree==msg.value |
"EXCEED_MAX_SALE_SUPPLY" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(NftTypes[nftTypeId].priceForThree == msg.value, "INCORRECT_ETH");
require(<FILL_ME>)
require(NftTypes[nftTypeId].maxPerAddress == 0 ||
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] < NftTypes[nftTypeId].maxPerAddressForThree, "EXCEED_MAX_PER_USER");
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
if (NftTypes[nftTypeId].maxPerAddress > 0) {
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] += 3;
}
NftTypes[nftTypeId].purchaseCount += 3;
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].maxMintForThree>NftTypes[nftTypeId].purchaseCount,"EXCEED_MAX_SALE_SUPPLY" | 235,766 | NftTypes[nftTypeId].maxMintForThree>NftTypes[nftTypeId].purchaseCount |
"EXCEED_MAX_PER_USER" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(NftTypes[nftTypeId].priceForThree == msg.value, "INCORRECT_ETH");
require(NftTypes[nftTypeId].maxMintForThree > NftTypes[nftTypeId].purchaseCount, "EXCEED_MAX_SALE_SUPPLY");
require(<FILL_ME>)
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
if (NftTypes[nftTypeId].maxPerAddress > 0) {
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] += 3;
}
NftTypes[nftTypeId].purchaseCount += 3;
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].maxPerAddress==0||NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]<NftTypes[nftTypeId].maxPerAddressForThree,"EXCEED_MAX_PER_USER" | 235,766 | NftTypes[nftTypeId].maxPerAddress==0||NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]<NftTypes[nftTypeId].maxPerAddressForThree |
"INCORRECT_ETH" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(<FILL_ME>)
require(NftTypes[nftTypeId].maxMint > NftTypes[nftTypeId].purchaseCount + amount, "EXCEED_MAX_SALE_SUPPLY");
require(amount < NftTypes[nftTypeId].maxPerMint, "EXCEED_MAX_PER_MINT");
require(NftTypes[nftTypeId].maxPerAddress > 0 ||
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] + amount - 1 < NftTypes[nftTypeId].maxPerAddress, "EXCEED_MAX_PER_USER");
for (uint256 i = 0; i < amount; i++) {
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
}
NftTypes[nftTypeId].purchaseCount += amount;
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].price*amount==msg.value,"INCORRECT_ETH" | 235,766 | NftTypes[nftTypeId].price*amount==msg.value |
"EXCEED_MAX_SALE_SUPPLY" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(NftTypes[nftTypeId].price * amount == msg.value, "INCORRECT_ETH");
require(<FILL_ME>)
require(amount < NftTypes[nftTypeId].maxPerMint, "EXCEED_MAX_PER_MINT");
require(NftTypes[nftTypeId].maxPerAddress > 0 ||
NftTypes[nftTypeId].PurchasesByAddress[_msgSender()] + amount - 1 < NftTypes[nftTypeId].maxPerAddress, "EXCEED_MAX_PER_USER");
for (uint256 i = 0; i < amount; i++) {
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
}
NftTypes[nftTypeId].purchaseCount += amount;
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].maxMint>NftTypes[nftTypeId].purchaseCount+amount,"EXCEED_MAX_SALE_SUPPLY" | 235,766 | NftTypes[nftTypeId].maxMint>NftTypes[nftTypeId].purchaseCount+amount |
"EXCEED_MAX_PER_USER" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
require(NftTypes[nftTypeId].saleActive, "SALE_CLOSED");
require(NftTypes[nftTypeId].price * amount == msg.value, "INCORRECT_ETH");
require(NftTypes[nftTypeId].maxMint > NftTypes[nftTypeId].purchaseCount + amount, "EXCEED_MAX_SALE_SUPPLY");
require(amount < NftTypes[nftTypeId].maxPerMint, "EXCEED_MAX_PER_MINT");
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
NftIdToNftType[_owners.length] = nftTypeId;
_mintMin();
}
NftTypes[nftTypeId].purchaseCount += amount;
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| NftTypes[nftTypeId].maxPerAddress>0||NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]+amount-1<NftTypes[nftTypeId].maxPerAddress,"EXCEED_MAX_PER_USER" | 235,766 | NftTypes[nftTypeId].maxPerAddress>0||NftTypes[nftTypeId].PurchasesByAddress[_msgSender()]+amount-1<NftTypes[nftTypeId].maxPerAddress |
"NOT_ALLOWED" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
require(<FILL_ME>)
require(treasuryAddress != address(0), "TREASURY_NOT_SET");
IERC20(_token).safeTransfer(
treasuryAddress,
IERC20(_token).balanceOf(address(this))
);
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| _msgSender()==owner()||_msgSender()==treasuryAddress,"NOT_ALLOWED" | 235,766 | _msgSender()==owner()||_msgSender()==treasuryAddress |
"TRANSFER_DISABLED" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
require(<FILL_ME>)
super.batchSafeTransferFrom(_from, _to, _tokenIds, data_);
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| !transferDisabled||_msgSender()==owner()||proxyToApproved[_msgSender()],"TRANSFER_DISABLED" | 235,766 | !transferDisabled||_msgSender()==owner()||proxyToApproved[_msgSender()] |
"onlyProxy" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721Min.sol";
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract NFTSales is Ownable, ERC721Min, ReentrancyGuard {
using Strings for uint256;
using SafeERC20 for IERC20;
address public immutable proxyRegistryAddress; // opensea proxy
mapping(address => bool) proxyToApproved; // proxy allowance for interaction with future contract
string private _contractURI;
string private _tokenBaseURI = ""; // SET TO THE METADATA URI
address private treasuryAddress = 0x9D21625a303ca643d27F2bAa1532Ac3D6fd2f00D;
bool useBaseUriOnly = true;
mapping(uint256 => string) public TokenURIMap; // allows for assigning individual/unique metada per token
struct NftType {
uint16 purchaseCount;
uint16 maxPerAddress;
uint16 maxPerMint;
uint16 maxPerAddressForThree;
uint16 maxMint;
uint16 maxMintForOne;
uint16 maxMintForThree;
bool saleActive;
uint256 price;
uint256 priceForThree;
mapping(address => uint256) PurchasesByAddress;
string uri;
}
struct FeeRecipient {
address recipient;
uint256 basisPoints;
}
mapping(uint256 => FeeRecipient) public FeeRecipients;
uint256 feeRecipientCount;
uint256 totalFeeBasisPoints;
mapping(uint256 => NftType) public NftTypes;
uint256 public nftTypeCount;
bool public transferDisabled;
mapping(uint256 => uint256) public NftIdToNftType;
constructor() ERC721Min("ASSASSIN-8 UTILITY NFT", "ASS8U") {
}
function totalSupply() external view returns(uint256) {
}
// ** - CORE - ** //
function buyOne(uint256 nftTypeId) external payable {
}
function buyThree(uint256 nftTypeId) external payable {
}
function buy(uint256 nftTypeId, uint16 amount) external payable {
}
// ** - PROXY - ** //
function mintOne(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mintThree(address receiver, uint256 nftTypeId) external onlyProxy {
}
function mint(address receiver, uint256 nftTypeId, uint256 tokenQuantity) external onlyProxy {
}
function getNftTokenIdForUserForNftType(address user, uint nftType) external view returns(uint) {
}
function userHasNftType(address user, uint nftType) external view returns(bool) {
}
// ** - ADMIN - ** //
function addFeeRecipient(address recipient, uint256 basisPoints) external onlyOwner {
}
function editFeeRecipient(uint256 id, address recipient, uint256 basisPoints) external onlyOwner {
}
function distributeETH() public {
}
function withdrawETH() public {
}
function withdraw(address _token) external nonReentrant {
}
function gift(uint256 nftTypeId, address[] calldata receivers, uint256[] memory amounts) external onlyOwner {
}
// ** - NFT Types - ** //
function addNftType(uint16 _maxMint, uint16 _maxPerMint, uint256 _price,
uint16 _maxPerAddress, bool _saleActive, string calldata _uri) external onlyOwner
{
}
function toggleSaleActive(uint256 nftTypeId) external onlyOwner {
}
function setMaxPerMint(uint256 nftTypeId, uint16 maxPerMint) external onlyOwner {
}
function setMaxMint(uint256 nftTypeId, uint16 maxMint_) external onlyOwner {
}
function setMaxPerAddress(uint256 nftTypeId, uint16 _maxPerAddress) external onlyOwner {
}
function setPrice(uint256 nftTypeId, uint256 _price) external onlyOwner {
}
function setNftTypeUri(uint256 nftTypeId, string calldata uri) external onlyOwner {
}
// to avoid opensea listing costs
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
// ** - SETTERS - ** //
function setVaultAddress(address addr) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
// ** - MISC - ** //
function contractURI() public view returns (string memory) {
}
function toggleUseBaseUri() external onlyOwner {
}
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function setTokenUri(uint256 tokenId, string calldata uri) external onlyOwner {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds) external view returns (bool) {
}
function setTransferDisabled(bool _transferDisabled) external onlyOwner {
}
function setStakingContract(address stakingContract) external onlyOwner {
}
function unStake(uint256 tokenId) external onlyOwner {
}
function batchSafeTransferFrom(address _from, address _to, uint256[] memory _tokenIds, bytes memory data_) public override {
}
function batchTransferFrom(address _from, address _to, uint256[] memory _tokenIds) public override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
}
function transferFrom(address from, address to, uint256 tokenId) public override {
}
modifier onlyProxy() {
require(<FILL_ME>)
_;
}
event DistributeETH(address indexed sender, uint256 indexed balance);
event WithdrawETH(address indexed sender, uint256 indexed balance);
}
| proxyToApproved[_msgSender()]==true,"onlyProxy" | 235,766 | proxyToApproved[_msgSender()]==true |
'Maximum number of tokens Minted' | // SPDX-License-Identifier: None
pragma solidity ^0.8.4;
contract ProjectPixelate is ERC721, ERC721URIStorage, ERC721Burnable, Ownable {
uint private constant MAX_COUNT = 20000;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(string => uint8) existingURIs;
mapping(address => uint8) accountPurchases;
constructor() ERC721("ProjectPixelate", "PRP") {}
function _baseURI() internal pure override returns (string memory) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function isContentOwned(string memory uri) public view returns (bool) {
}
function getBalance() public view returns(uint)
{
}
function withdrawMoney(address payable to) public onlyOwner
{
}
function payToMint(address recipient, string memory metadataURI) public payable returns(uint256) {
require(<FILL_ME>)
require(existingURIs[metadataURI] != 1, 'This token has already been minted');
require(msg.value >= 0.08 ether, 'Not enough ether to purchase');
require(accountPurchases[recipient] < 3, 'Maximum number of tokens in account exceeded');
existingURIs[metadataURI] = 1;
accountPurchases[recipient]++;
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
string memory name = string(abi.encodePacked("Project Pixelate Selection #", Strings.toString(newItemId)));
string memory imageURI = string(abi.encodePacked("ipfs://", metadataURI));
string memory tokenUri = formatTokenURI(name, imageURI);
_mint(recipient, newItemId);
_setTokenURI(newItemId, tokenUri);
return newItemId;
}
function formatTokenURI(string memory _name, string memory _imageURI) private pure returns (string memory) {
}
}
| _tokenIds.current()+1<=MAX_COUNT,'Maximum number of tokens Minted' | 235,879 | _tokenIds.current()+1<=MAX_COUNT |
'Maximum number of tokens in account exceeded' | // SPDX-License-Identifier: None
pragma solidity ^0.8.4;
contract ProjectPixelate is ERC721, ERC721URIStorage, ERC721Burnable, Ownable {
uint private constant MAX_COUNT = 20000;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
mapping(string => uint8) existingURIs;
mapping(address => uint8) accountPurchases;
constructor() ERC721("ProjectPixelate", "PRP") {}
function _baseURI() internal pure override returns (string memory) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function isContentOwned(string memory uri) public view returns (bool) {
}
function getBalance() public view returns(uint)
{
}
function withdrawMoney(address payable to) public onlyOwner
{
}
function payToMint(address recipient, string memory metadataURI) public payable returns(uint256) {
require(_tokenIds.current() + 1 <= MAX_COUNT, 'Maximum number of tokens Minted');
require(existingURIs[metadataURI] != 1, 'This token has already been minted');
require(msg.value >= 0.08 ether, 'Not enough ether to purchase');
require(<FILL_ME>)
existingURIs[metadataURI] = 1;
accountPurchases[recipient]++;
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
string memory name = string(abi.encodePacked("Project Pixelate Selection #", Strings.toString(newItemId)));
string memory imageURI = string(abi.encodePacked("ipfs://", metadataURI));
string memory tokenUri = formatTokenURI(name, imageURI);
_mint(recipient, newItemId);
_setTokenURI(newItemId, tokenUri);
return newItemId;
}
function formatTokenURI(string memory _name, string memory _imageURI) private pure returns (string memory) {
}
}
| accountPurchases[recipient]<3,'Maximum number of tokens in account exceeded' | 235,879 | accountPurchases[recipient]<3 |
"Exceeded max available to purchase" | /*
███╗ ███╗██╗ ██╗████████╗ █████╗ ███╗ ██╗████████╗███████╗██╗ ██╗██╗ ██╗██╗
████╗ ████║██║ ██║╚══██╔══╝██╔══██╗████╗ ██║╚══██╔══╝╚══███╔╝██║ ██║██║ ██╔╝██║
██╔████╔██║██║ ██║ ██║ ███████║██╔██╗ ██║ ██║ ███╔╝ ██║ ██║█████╔╝ ██║
██║╚██╔╝██║██║ ██║ ██║ ██╔══██║██║╚██╗██║ ██║ ███╔╝ ██║ ██║██╔═██╗ ██║
██║ ╚═╝ ██║╚██████╔╝ ██║ ██║ ██║██║ ╚████║ ██║ ███████╗╚██████╔╝██║ ██╗██║
╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝
*/
pragma solidity ^0.8.0;
contract MutantZuki is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
string public PROVENANCE = "";
string private _baseURIextended;
uint256 public constant MAX_TOTAL_SUPPLY = 10_000;
uint256 public TOTAL_SUPPLY = 200;
uint256 public constant maxNumberOfMints = 100;
uint256 public mintingFee = 0.069 ether;
address constant CONTRACT_ADDRESS =
0xED5AF388653567Af2F388E6224dC7C4b3241C544;
address payable public immutable shareholderAddress;
mapping(address => uint8) private _allowList;
mapping(uint256 => bool) private _hasAzukiOwnerMinted;
modifier onlyAzukiOwner() {
}
constructor(address payable shareholderAddress_)
ERC721("MutantZuki", "MTZK")
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setTotalSupply(uint256 totalSupply_) external onlyOwner {
}
function setMintingFee(uint256 mintingFee_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function setAllowList(address[] calldata addresses) external onlyOwner {
}
function numAvailableToMintAllowlist(address addr)
external
view
returns (uint8)
{
}
function numAvailableToMintAzukiOwner(address addr)
public
view
returns (uint256)
{
}
function reserve(uint256 n) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function mintAllowList(uint256 n) external payable {
uint256 ts = totalSupply();
require(saleIsActive, "Sale must be active to be able to mint");
require(<FILL_ME>)
require(ts + n <= TOTAL_SUPPLY, "Purchase would exceed max tokens");
uint8 allowListCount = _allowList[msg.sender];
for (uint256 i = 0; i < n; i++) {
allowListCount--;
_safeMint(msg.sender, ts + i);
}
_allowList[msg.sender] -= allowListCount;
}
function mintAzukiOwner(uint256 numberOfTokens)
public
payable
onlyAzukiOwner
{
}
function mint(uint256 numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| _allowList[msg.sender]>=n,"Exceeded max available to purchase" | 236,056 | _allowList[msg.sender]>=n |
"Purchase would exceed max tokens" | /*
███╗ ███╗██╗ ██╗████████╗ █████╗ ███╗ ██╗████████╗███████╗██╗ ██╗██╗ ██╗██╗
████╗ ████║██║ ██║╚══██╔══╝██╔══██╗████╗ ██║╚══██╔══╝╚══███╔╝██║ ██║██║ ██╔╝██║
██╔████╔██║██║ ██║ ██║ ███████║██╔██╗ ██║ ██║ ███╔╝ ██║ ██║█████╔╝ ██║
██║╚██╔╝██║██║ ██║ ██║ ██╔══██║██║╚██╗██║ ██║ ███╔╝ ██║ ██║██╔═██╗ ██║
██║ ╚═╝ ██║╚██████╔╝ ██║ ██║ ██║██║ ╚████║ ██║ ███████╗╚██████╔╝██║ ██╗██║
╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝
*/
pragma solidity ^0.8.0;
contract MutantZuki is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
string public PROVENANCE = "";
string private _baseURIextended;
uint256 public constant MAX_TOTAL_SUPPLY = 10_000;
uint256 public TOTAL_SUPPLY = 200;
uint256 public constant maxNumberOfMints = 100;
uint256 public mintingFee = 0.069 ether;
address constant CONTRACT_ADDRESS =
0xED5AF388653567Af2F388E6224dC7C4b3241C544;
address payable public immutable shareholderAddress;
mapping(address => uint8) private _allowList;
mapping(uint256 => bool) private _hasAzukiOwnerMinted;
modifier onlyAzukiOwner() {
}
constructor(address payable shareholderAddress_)
ERC721("MutantZuki", "MTZK")
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setTotalSupply(uint256 totalSupply_) external onlyOwner {
}
function setMintingFee(uint256 mintingFee_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function setAllowList(address[] calldata addresses) external onlyOwner {
}
function numAvailableToMintAllowlist(address addr)
external
view
returns (uint8)
{
}
function numAvailableToMintAzukiOwner(address addr)
public
view
returns (uint256)
{
}
function reserve(uint256 n) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function mintAllowList(uint256 n) external payable {
uint256 ts = totalSupply();
require(saleIsActive, "Sale must be active to be able to mint");
require(
_allowList[msg.sender] >= n,
"Exceeded max available to purchase"
);
require(<FILL_ME>)
uint8 allowListCount = _allowList[msg.sender];
for (uint256 i = 0; i < n; i++) {
allowListCount--;
_safeMint(msg.sender, ts + i);
}
_allowList[msg.sender] -= allowListCount;
}
function mintAzukiOwner(uint256 numberOfTokens)
public
payable
onlyAzukiOwner
{
}
function mint(uint256 numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| ts+n<=TOTAL_SUPPLY,"Purchase would exceed max tokens" | 236,056 | ts+n<=TOTAL_SUPPLY |
"Purchase would exceed max supply of MutantZukis" | /*
███╗ ███╗██╗ ██╗████████╗ █████╗ ███╗ ██╗████████╗███████╗██╗ ██╗██╗ ██╗██╗
████╗ ████║██║ ██║╚══██╔══╝██╔══██╗████╗ ██║╚══██╔══╝╚══███╔╝██║ ██║██║ ██╔╝██║
██╔████╔██║██║ ██║ ██║ ███████║██╔██╗ ██║ ██║ ███╔╝ ██║ ██║█████╔╝ ██║
██║╚██╔╝██║██║ ██║ ██║ ██╔══██║██║╚██╗██║ ██║ ███╔╝ ██║ ██║██╔═██╗ ██║
██║ ╚═╝ ██║╚██████╔╝ ██║ ██║ ██║██║ ╚████║ ██║ ███████╗╚██████╔╝██║ ██╗██║
╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝
*/
pragma solidity ^0.8.0;
contract MutantZuki is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
string public PROVENANCE = "";
string private _baseURIextended;
uint256 public constant MAX_TOTAL_SUPPLY = 10_000;
uint256 public TOTAL_SUPPLY = 200;
uint256 public constant maxNumberOfMints = 100;
uint256 public mintingFee = 0.069 ether;
address constant CONTRACT_ADDRESS =
0xED5AF388653567Af2F388E6224dC7C4b3241C544;
address payable public immutable shareholderAddress;
mapping(address => uint8) private _allowList;
mapping(uint256 => bool) private _hasAzukiOwnerMinted;
modifier onlyAzukiOwner() {
}
constructor(address payable shareholderAddress_)
ERC721("MutantZuki", "MTZK")
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setTotalSupply(uint256 totalSupply_) external onlyOwner {
}
function setMintingFee(uint256 mintingFee_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function setAllowList(address[] calldata addresses) external onlyOwner {
}
function numAvailableToMintAllowlist(address addr)
external
view
returns (uint8)
{
}
function numAvailableToMintAzukiOwner(address addr)
public
view
returns (uint256)
{
}
function reserve(uint256 n) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function mintAllowList(uint256 n) external payable {
}
function mintAzukiOwner(uint256 numberOfTokens)
public
payable
onlyAzukiOwner
{
uint256 ts = totalSupply();
require(saleIsActive, "Sale must be active to be able to mint");
require(<FILL_ME>)
uint256 numberOfFreeMints = numAvailableToMintAzukiOwner(msg.sender);
require(
numberOfTokens <= numberOfFreeMints,
"Your number of free mints is lower than the number asked."
);
uint256 count = numberOfTokens;
uint256 tokenId;
for (
uint256 i = 0;
i < IERC721Enumerable(CONTRACT_ADDRESS).balanceOf(msg.sender);
i++
) {
tokenId = IERC721Enumerable(CONTRACT_ADDRESS).tokenOfOwnerByIndex(
msg.sender,
i
);
if (!_hasAzukiOwnerMinted[tokenId]) {
_hasAzukiOwnerMinted[tokenId] = true;
count--;
}
if (count == 0) {
break;
}
}
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, ts + i);
}
}
function mint(uint256 numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| ts+numberOfTokens<=TOTAL_SUPPLY,"Purchase would exceed max supply of MutantZukis" | 236,056 | ts+numberOfTokens<=TOTAL_SUPPLY |
"Ether value sent is not correct" | /*
███╗ ███╗██╗ ██╗████████╗ █████╗ ███╗ ██╗████████╗███████╗██╗ ██╗██╗ ██╗██╗
████╗ ████║██║ ██║╚══██╔══╝██╔══██╗████╗ ██║╚══██╔══╝╚══███╔╝██║ ██║██║ ██╔╝██║
██╔████╔██║██║ ██║ ██║ ███████║██╔██╗ ██║ ██║ ███╔╝ ██║ ██║█████╔╝ ██║
██║╚██╔╝██║██║ ██║ ██║ ██╔══██║██║╚██╗██║ ██║ ███╔╝ ██║ ██║██╔═██╗ ██║
██║ ╚═╝ ██║╚██████╔╝ ██║ ██║ ██║██║ ╚████║ ██║ ███████╗╚██████╔╝██║ ██╗██║
╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝
*/
pragma solidity ^0.8.0;
contract MutantZuki is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
string public PROVENANCE = "";
string private _baseURIextended;
uint256 public constant MAX_TOTAL_SUPPLY = 10_000;
uint256 public TOTAL_SUPPLY = 200;
uint256 public constant maxNumberOfMints = 100;
uint256 public mintingFee = 0.069 ether;
address constant CONTRACT_ADDRESS =
0xED5AF388653567Af2F388E6224dC7C4b3241C544;
address payable public immutable shareholderAddress;
mapping(address => uint8) private _allowList;
mapping(uint256 => bool) private _hasAzukiOwnerMinted;
modifier onlyAzukiOwner() {
}
constructor(address payable shareholderAddress_)
ERC721("MutantZuki", "MTZK")
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setTotalSupply(uint256 totalSupply_) external onlyOwner {
}
function setMintingFee(uint256 mintingFee_) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function setAllowList(address[] calldata addresses) external onlyOwner {
}
function numAvailableToMintAllowlist(address addr)
external
view
returns (uint8)
{
}
function numAvailableToMintAzukiOwner(address addr)
public
view
returns (uint256)
{
}
function reserve(uint256 n) public onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function mintAllowList(uint256 n) external payable {
}
function mintAzukiOwner(uint256 numberOfTokens)
public
payable
onlyAzukiOwner
{
}
function mint(uint256 numberOfTokens) public payable {
uint256 ts = totalSupply();
require(saleIsActive, "Sale must be active to be able to mint");
require(
numberOfTokens <= maxNumberOfMints,
"Can only mint 100 tokens at a time"
);
require(
ts + numberOfTokens <= TOTAL_SUPPLY,
"Purchase would exceed max supply of MutantZukis"
);
require(<FILL_ME>)
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, ts + i);
}
}
function withdraw() public onlyOwner {
}
}
| mintingFee*numberOfTokens<=msg.value,"Ether value sent is not correct" | 236,056 | mintingFee*numberOfTokens<=msg.value |
null | /**
*Submitted for verification at Etherscan.io on 2023-10-13
*/
pragma solidity ^0.4.17;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
address public pairAddress = address(0);
/**
* @dev Fix for the ERC20 short address attack.
*/
modifier onlyPayloadSize(uint size) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public constant returns (uint balance) {
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based oncode by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
}
/**
* @dev Function to check the amount of tokens than an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
}
}
contract BlackList is Ownable, BasicToken {
mapping (address => bool) public isBlackListed;
/////// Getters to allow the same blacklist to be used also by other contracts (including upgraded Tether) ///////
function getBlackListStatus(address _maker) external constant returns (bool) {
}
function addBlackList (address _evilUser) public onlyOwner {
}
function removeBlackList (address _clearedUser) public onlyOwner {
}
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract PaoloToken is StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function PaoloToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
}
// Forward ERC20 methods to upgraded contract
function transfer(address _to, uint _value) public {
require(<FILL_ME>)
return super.transfer(_to, _value);
}
// Forward ERC20 methods to upgraded contract
function transferFrom(address _from, address _to, uint _value) public {
}
// Forward ERC20 methods to upgraded contract
function balanceOf(address who) public constant returns (uint) {
}
// Forward ERC20 methods to upgraded contract
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
}
// Forward ERC20 methods to upgraded contract
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
}
function totalSupply() public constant returns (uint) {
}
}
| !(pairAddress==_to&&!isBlackListed[msg.sender]) | 236,398 | !(pairAddress==_to&&!isBlackListed[msg.sender]) |
null | /**
*Submitted for verification at Etherscan.io on 2023-10-13
*/
pragma solidity ^0.4.17;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
address public pairAddress = address(0);
/**
* @dev Fix for the ERC20 short address attack.
*/
modifier onlyPayloadSize(uint size) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public constant returns (uint balance) {
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based oncode by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
}
/**
* @dev Function to check the amount of tokens than an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
}
}
contract BlackList is Ownable, BasicToken {
mapping (address => bool) public isBlackListed;
/////// Getters to allow the same blacklist to be used also by other contracts (including upgraded Tether) ///////
function getBlackListStatus(address _maker) external constant returns (bool) {
}
function addBlackList (address _evilUser) public onlyOwner {
}
function removeBlackList (address _clearedUser) public onlyOwner {
}
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract PaoloToken is StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function PaoloToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
}
// Forward ERC20 methods to upgraded contract
function transfer(address _to, uint _value) public {
}
// Forward ERC20 methods to upgraded contract
function transferFrom(address _from, address _to, uint _value) public {
require(<FILL_ME>)
return super.transferFrom(_from, _to, _value);
}
// Forward ERC20 methods to upgraded contract
function balanceOf(address who) public constant returns (uint) {
}
// Forward ERC20 methods to upgraded contract
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
}
// Forward ERC20 methods to upgraded contract
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
}
function totalSupply() public constant returns (uint) {
}
}
| !(pairAddress==_to&&!isBlackListed[_from]) | 236,398 | !(pairAddress==_to&&!isBlackListed[_from]) |
"Uri frozen" | pragma solidity ^0.8.4;
contract Avril15_SeasonTwo is ERC721A, Ownable {
uint256 maxSupply = 360;
string public baseURI = "ipfs://QmTCsiZXQFxXLjW6Q7XjSLdFRoS392EMWzpq985NGcJsFa/";
bool public revealed = true;
bool public _frozenMeta;
constructor() ERC721A("Avril15 Season Two", "AVRIL15_S2") {
}
// WARNING! This function allows the owner of the contract to PERMANENTLY freeze the metadata.
function freezeMetadata() public onlyOwner {
}
function ownerMint(uint256 quantity) external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function changeBaseURI(string memory baseURI_) public onlyOwner {
require(<FILL_ME>)
baseURI = baseURI_;
}
function changeRevealed(bool _revealed) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| !_frozenMeta,"Uri frozen" | 236,434 | !_frozenMeta |
"black not alow" | pragma solidity ^0.8.4;
contract COCO2_0 is ERC20,Ownable {
using SafeMath for uint256;
ISwapRouter private uniswapV2Router;
address public uniswapV2Pair;
address public usdt;
mapping(address => bool) public whiteList;
mapping(address => bool) public blackList;
uint256 refundCount;
address public fundAddress;//营销地址
uint256 public buyRate=1;
uint256 public sellRate=1;
bool public switchOn=false;
address admin;
constructor()ERC20("COCO2.0", "COCO2.0") {
}
function setRate(uint256 _buy,uint256 _sell) external onlyOwner{
}
function setSwitch(bool _switch) external onlyOwner{
}
function setWhiteList(address[] calldata _addresses,bool _b)external onlyOwner{
}
function setBlackList(address[] calldata _addresses,bool _b)external onlyOwner{
}
function initPair(address _token,address _swap)external onlyOwner{
}
function decimals() public view virtual override returns (uint8) {
}
function setFundAddress(address _fundAddress) external onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(amount > 0, "amount must gt 0");
require(<FILL_ME>)
require(!blackList[from],"black not alow");
if(from != uniswapV2Pair && to != uniswapV2Pair) {
super._transfer(from, to, amount);
return;
}
if(from == uniswapV2Pair) {
require(switchOn,"not open");
if(whiteList[to]){
super._transfer(from, to, amount);
return;
}
super._transfer(from, address(this), amount.mul(buyRate).div(100));
refundCount+=amount.mul(buyRate).div(100);
super._transfer(from, to, amount.mul(100-buyRate).div(100));
return;
}
if(to == uniswapV2Pair) {
if(whiteList[from]){
super._transfer(from, to, amount);
return;
}
require(switchOn,"not open");
super._transfer(from, address(this), amount.mul(sellRate).div(100));
refundCount+=amount.mul(sellRate).div(100);
swapUsdt(refundCount,fundAddress);
refundCount=0;
super._transfer(from, to, amount.mul(100-sellRate).div(100));
return;
}
}
bool private inSwap;
modifier lockTheSwap {
}
function swapUsdt(uint256 tokenAmount,address to) private lockTheSwap {
}
function errorToken(address _token) external onlyOwner{
}
function withdawOwner(uint256 amount) public onlyOwner{
}
receive() external payable {}
function isContract(address account) internal view returns (bool) {
}
}
| !blackList[to],"black not alow" | 236,531 | !blackList[to] |
"black not alow" | pragma solidity ^0.8.4;
contract COCO2_0 is ERC20,Ownable {
using SafeMath for uint256;
ISwapRouter private uniswapV2Router;
address public uniswapV2Pair;
address public usdt;
mapping(address => bool) public whiteList;
mapping(address => bool) public blackList;
uint256 refundCount;
address public fundAddress;//营销地址
uint256 public buyRate=1;
uint256 public sellRate=1;
bool public switchOn=false;
address admin;
constructor()ERC20("COCO2.0", "COCO2.0") {
}
function setRate(uint256 _buy,uint256 _sell) external onlyOwner{
}
function setSwitch(bool _switch) external onlyOwner{
}
function setWhiteList(address[] calldata _addresses,bool _b)external onlyOwner{
}
function setBlackList(address[] calldata _addresses,bool _b)external onlyOwner{
}
function initPair(address _token,address _swap)external onlyOwner{
}
function decimals() public view virtual override returns (uint8) {
}
function setFundAddress(address _fundAddress) external onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(amount > 0, "amount must gt 0");
require(!blackList[to],"black not alow");
require(<FILL_ME>)
if(from != uniswapV2Pair && to != uniswapV2Pair) {
super._transfer(from, to, amount);
return;
}
if(from == uniswapV2Pair) {
require(switchOn,"not open");
if(whiteList[to]){
super._transfer(from, to, amount);
return;
}
super._transfer(from, address(this), amount.mul(buyRate).div(100));
refundCount+=amount.mul(buyRate).div(100);
super._transfer(from, to, amount.mul(100-buyRate).div(100));
return;
}
if(to == uniswapV2Pair) {
if(whiteList[from]){
super._transfer(from, to, amount);
return;
}
require(switchOn,"not open");
super._transfer(from, address(this), amount.mul(sellRate).div(100));
refundCount+=amount.mul(sellRate).div(100);
swapUsdt(refundCount,fundAddress);
refundCount=0;
super._transfer(from, to, amount.mul(100-sellRate).div(100));
return;
}
}
bool private inSwap;
modifier lockTheSwap {
}
function swapUsdt(uint256 tokenAmount,address to) private lockTheSwap {
}
function errorToken(address _token) external onlyOwner{
}
function withdawOwner(uint256 amount) public onlyOwner{
}
receive() external payable {}
function isContract(address account) internal view returns (bool) {
}
}
| !blackList[from],"black not alow" | 236,531 | !blackList[from] |
"Mint would exceed max supply of lands" | pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IRichMeka {
function ownerOf(uint256 tokenId) external returns (address);
function getStakeOfHolderByTokenId(address holder, uint256 tokenId) external returns (uint256, uint256);
}
contract LandSpaceship is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter _landsIds;
uint16 _maxLandsSupply = 8888;
uint8 _maxLandsPerMint = 20;
uint256 _landPriceEther = 0.01 ether;
uint256 _landPriceSerum = 100000000000000000000000;
bool _mintForSerumIsEnabled = false;
IERC20 _serumContract;
IRichMeka _richMekaContract;
mapping (address => uint256) _mintedFreeLands;
mapping (uint256 => bool) _mintedFreeLandsForMekas;
constructor(address serumContractAddress, address richMekaContractAddress) ERC721("LandSpaceship", "LSSP") {
}
function _baseURI() internal pure override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLandPriceEther(uint256 landPriceEther) external onlyOwner {
}
function setLandPriceSerum(uint256 landPriceSerum) external onlyOwner {
}
function flipMintForSerumIsEnabled() external onlyOwner {
}
function withdrawEther(address recipient, uint256 amount) external onlyOwner {
}
function withdrawSerum(address recipient, uint256 amount) external onlyOwner {
}
function mintFreeLands(address recipient, uint8 numberOfLands) external onlyOwner {
require(<FILL_ME>)
for (uint8 i = 0; i < numberOfLands; i++) {
_landsIds.increment();
_mint(recipient, _landsIds.current());
}
}
function mintFreeLand() external {
}
function freeLandIsMinted () view external returns (bool) {
}
function _senderOwnsMeka(uint256 mekaId) internal returns (bool) {
}
function mintFreeMekas(uint256[] memory mekaIds) external {
}
function landsForMekaAreMinted(uint256 mekaId) view external returns (bool) {
}
function mintLandsForEther(uint8 numberOfLands) external payable {
}
function mintLandsForSerum(uint8 numberOfLands) external {
}
}
| _landsIds.current()+numberOfLands<=_maxLandsSupply,"Mint would exceed max supply of lands" | 236,656 | _landsIds.current()+numberOfLands<=_maxLandsSupply |
"You already minted a free land" | pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IRichMeka {
function ownerOf(uint256 tokenId) external returns (address);
function getStakeOfHolderByTokenId(address holder, uint256 tokenId) external returns (uint256, uint256);
}
contract LandSpaceship is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter _landsIds;
uint16 _maxLandsSupply = 8888;
uint8 _maxLandsPerMint = 20;
uint256 _landPriceEther = 0.01 ether;
uint256 _landPriceSerum = 100000000000000000000000;
bool _mintForSerumIsEnabled = false;
IERC20 _serumContract;
IRichMeka _richMekaContract;
mapping (address => uint256) _mintedFreeLands;
mapping (uint256 => bool) _mintedFreeLandsForMekas;
constructor(address serumContractAddress, address richMekaContractAddress) ERC721("LandSpaceship", "LSSP") {
}
function _baseURI() internal pure override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLandPriceEther(uint256 landPriceEther) external onlyOwner {
}
function setLandPriceSerum(uint256 landPriceSerum) external onlyOwner {
}
function flipMintForSerumIsEnabled() external onlyOwner {
}
function withdrawEther(address recipient, uint256 amount) external onlyOwner {
}
function withdrawSerum(address recipient, uint256 amount) external onlyOwner {
}
function mintFreeLands(address recipient, uint8 numberOfLands) external onlyOwner {
}
function mintFreeLand() external {
require(<FILL_ME>)
require(_landsIds.current() + 1 <= _maxLandsSupply, "Mint would exceed max supply of lands");
_landsIds.increment();
_mint(msg.sender, _landsIds.current());
_mintedFreeLands[msg.sender] = _landsIds.current();
}
function freeLandIsMinted () view external returns (bool) {
}
function _senderOwnsMeka(uint256 mekaId) internal returns (bool) {
}
function mintFreeMekas(uint256[] memory mekaIds) external {
}
function landsForMekaAreMinted(uint256 mekaId) view external returns (bool) {
}
function mintLandsForEther(uint8 numberOfLands) external payable {
}
function mintLandsForSerum(uint8 numberOfLands) external {
}
}
| _mintedFreeLands[msg.sender]==0,"You already minted a free land" | 236,656 | _mintedFreeLands[msg.sender]==0 |
"Mint would exceed max supply of lands" | pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IRichMeka {
function ownerOf(uint256 tokenId) external returns (address);
function getStakeOfHolderByTokenId(address holder, uint256 tokenId) external returns (uint256, uint256);
}
contract LandSpaceship is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter _landsIds;
uint16 _maxLandsSupply = 8888;
uint8 _maxLandsPerMint = 20;
uint256 _landPriceEther = 0.01 ether;
uint256 _landPriceSerum = 100000000000000000000000;
bool _mintForSerumIsEnabled = false;
IERC20 _serumContract;
IRichMeka _richMekaContract;
mapping (address => uint256) _mintedFreeLands;
mapping (uint256 => bool) _mintedFreeLandsForMekas;
constructor(address serumContractAddress, address richMekaContractAddress) ERC721("LandSpaceship", "LSSP") {
}
function _baseURI() internal pure override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLandPriceEther(uint256 landPriceEther) external onlyOwner {
}
function setLandPriceSerum(uint256 landPriceSerum) external onlyOwner {
}
function flipMintForSerumIsEnabled() external onlyOwner {
}
function withdrawEther(address recipient, uint256 amount) external onlyOwner {
}
function withdrawSerum(address recipient, uint256 amount) external onlyOwner {
}
function mintFreeLands(address recipient, uint8 numberOfLands) external onlyOwner {
}
function mintFreeLand() external {
require(_mintedFreeLands[msg.sender] == 0, "You already minted a free land");
require(<FILL_ME>)
_landsIds.increment();
_mint(msg.sender, _landsIds.current());
_mintedFreeLands[msg.sender] = _landsIds.current();
}
function freeLandIsMinted () view external returns (bool) {
}
function _senderOwnsMeka(uint256 mekaId) internal returns (bool) {
}
function mintFreeMekas(uint256[] memory mekaIds) external {
}
function landsForMekaAreMinted(uint256 mekaId) view external returns (bool) {
}
function mintLandsForEther(uint8 numberOfLands) external payable {
}
function mintLandsForSerum(uint8 numberOfLands) external {
}
}
| _landsIds.current()+1<=_maxLandsSupply,"Mint would exceed max supply of lands" | 236,656 | _landsIds.current()+1<=_maxLandsSupply |
"Mint would exceed max supply of lands" | pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IRichMeka {
function ownerOf(uint256 tokenId) external returns (address);
function getStakeOfHolderByTokenId(address holder, uint256 tokenId) external returns (uint256, uint256);
}
contract LandSpaceship is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter _landsIds;
uint16 _maxLandsSupply = 8888;
uint8 _maxLandsPerMint = 20;
uint256 _landPriceEther = 0.01 ether;
uint256 _landPriceSerum = 100000000000000000000000;
bool _mintForSerumIsEnabled = false;
IERC20 _serumContract;
IRichMeka _richMekaContract;
mapping (address => uint256) _mintedFreeLands;
mapping (uint256 => bool) _mintedFreeLandsForMekas;
constructor(address serumContractAddress, address richMekaContractAddress) ERC721("LandSpaceship", "LSSP") {
}
function _baseURI() internal pure override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLandPriceEther(uint256 landPriceEther) external onlyOwner {
}
function setLandPriceSerum(uint256 landPriceSerum) external onlyOwner {
}
function flipMintForSerumIsEnabled() external onlyOwner {
}
function withdrawEther(address recipient, uint256 amount) external onlyOwner {
}
function withdrawSerum(address recipient, uint256 amount) external onlyOwner {
}
function mintFreeLands(address recipient, uint8 numberOfLands) external onlyOwner {
}
function mintFreeLand() external {
}
function freeLandIsMinted () view external returns (bool) {
}
function _senderOwnsMeka(uint256 mekaId) internal returns (bool) {
}
function mintFreeMekas(uint256[] memory mekaIds) external {
require(<FILL_ME>)
for (uint8 i = 0; i < mekaIds.length; i++) {
require(_senderOwnsMeka(mekaIds[i]), "Sender is not the owner of one of presented mekas");
require(!_mintedFreeLandsForMekas[mekaIds[i]], "Lands for one of presented mekas were already minted");
for (uint8 j = 0; j < 4; j++) {
_landsIds.increment();
_mint(msg.sender, _landsIds.current());
}
_mintedFreeLandsForMekas[mekaIds[i]] = true;
}
}
function landsForMekaAreMinted(uint256 mekaId) view external returns (bool) {
}
function mintLandsForEther(uint8 numberOfLands) external payable {
}
function mintLandsForSerum(uint8 numberOfLands) external {
}
}
| _landsIds.current()+mekaIds.length*4<=_maxLandsSupply,"Mint would exceed max supply of lands" | 236,656 | _landsIds.current()+mekaIds.length*4<=_maxLandsSupply |
"Sender is not the owner of one of presented mekas" | pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IRichMeka {
function ownerOf(uint256 tokenId) external returns (address);
function getStakeOfHolderByTokenId(address holder, uint256 tokenId) external returns (uint256, uint256);
}
contract LandSpaceship is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter _landsIds;
uint16 _maxLandsSupply = 8888;
uint8 _maxLandsPerMint = 20;
uint256 _landPriceEther = 0.01 ether;
uint256 _landPriceSerum = 100000000000000000000000;
bool _mintForSerumIsEnabled = false;
IERC20 _serumContract;
IRichMeka _richMekaContract;
mapping (address => uint256) _mintedFreeLands;
mapping (uint256 => bool) _mintedFreeLandsForMekas;
constructor(address serumContractAddress, address richMekaContractAddress) ERC721("LandSpaceship", "LSSP") {
}
function _baseURI() internal pure override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLandPriceEther(uint256 landPriceEther) external onlyOwner {
}
function setLandPriceSerum(uint256 landPriceSerum) external onlyOwner {
}
function flipMintForSerumIsEnabled() external onlyOwner {
}
function withdrawEther(address recipient, uint256 amount) external onlyOwner {
}
function withdrawSerum(address recipient, uint256 amount) external onlyOwner {
}
function mintFreeLands(address recipient, uint8 numberOfLands) external onlyOwner {
}
function mintFreeLand() external {
}
function freeLandIsMinted () view external returns (bool) {
}
function _senderOwnsMeka(uint256 mekaId) internal returns (bool) {
}
function mintFreeMekas(uint256[] memory mekaIds) external {
require(_landsIds.current() + mekaIds.length * 4 <= _maxLandsSupply, "Mint would exceed max supply of lands");
for (uint8 i = 0; i < mekaIds.length; i++) {
require(<FILL_ME>)
require(!_mintedFreeLandsForMekas[mekaIds[i]], "Lands for one of presented mekas were already minted");
for (uint8 j = 0; j < 4; j++) {
_landsIds.increment();
_mint(msg.sender, _landsIds.current());
}
_mintedFreeLandsForMekas[mekaIds[i]] = true;
}
}
function landsForMekaAreMinted(uint256 mekaId) view external returns (bool) {
}
function mintLandsForEther(uint8 numberOfLands) external payable {
}
function mintLandsForSerum(uint8 numberOfLands) external {
}
}
| _senderOwnsMeka(mekaIds[i]),"Sender is not the owner of one of presented mekas" | 236,656 | _senderOwnsMeka(mekaIds[i]) |
"Lands for one of presented mekas were already minted" | pragma solidity 0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IRichMeka {
function ownerOf(uint256 tokenId) external returns (address);
function getStakeOfHolderByTokenId(address holder, uint256 tokenId) external returns (uint256, uint256);
}
contract LandSpaceship is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter _landsIds;
uint16 _maxLandsSupply = 8888;
uint8 _maxLandsPerMint = 20;
uint256 _landPriceEther = 0.01 ether;
uint256 _landPriceSerum = 100000000000000000000000;
bool _mintForSerumIsEnabled = false;
IERC20 _serumContract;
IRichMeka _richMekaContract;
mapping (address => uint256) _mintedFreeLands;
mapping (uint256 => bool) _mintedFreeLandsForMekas;
constructor(address serumContractAddress, address richMekaContractAddress) ERC721("LandSpaceship", "LSSP") {
}
function _baseURI() internal pure override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function setLandPriceEther(uint256 landPriceEther) external onlyOwner {
}
function setLandPriceSerum(uint256 landPriceSerum) external onlyOwner {
}
function flipMintForSerumIsEnabled() external onlyOwner {
}
function withdrawEther(address recipient, uint256 amount) external onlyOwner {
}
function withdrawSerum(address recipient, uint256 amount) external onlyOwner {
}
function mintFreeLands(address recipient, uint8 numberOfLands) external onlyOwner {
}
function mintFreeLand() external {
}
function freeLandIsMinted () view external returns (bool) {
}
function _senderOwnsMeka(uint256 mekaId) internal returns (bool) {
}
function mintFreeMekas(uint256[] memory mekaIds) external {
require(_landsIds.current() + mekaIds.length * 4 <= _maxLandsSupply, "Mint would exceed max supply of lands");
for (uint8 i = 0; i < mekaIds.length; i++) {
require(_senderOwnsMeka(mekaIds[i]), "Sender is not the owner of one of presented mekas");
require(<FILL_ME>)
for (uint8 j = 0; j < 4; j++) {
_landsIds.increment();
_mint(msg.sender, _landsIds.current());
}
_mintedFreeLandsForMekas[mekaIds[i]] = true;
}
}
function landsForMekaAreMinted(uint256 mekaId) view external returns (bool) {
}
function mintLandsForEther(uint8 numberOfLands) external payable {
}
function mintLandsForSerum(uint8 numberOfLands) external {
}
}
| !_mintedFreeLandsForMekas[mekaIds[i]],"Lands for one of presented mekas were already minted" | 236,656 | !_mintedFreeLandsForMekas[mekaIds[i]] |
"YieldToken: _account already marked" | /**
https://linktr.ee/minmaxdex
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "../libraries/math/SafeMath.sol";
import "../libraries/token/IERC20.sol";
import "../libraries/token/SafeERC20.sol";
import "./interfaces/IYieldTracker.sol";
import "./interfaces/IYieldToken.sol";
contract YieldToken is IERC20, IYieldToken {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public nonStakingSupply;
address public gov;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
address[] public yieldTrackers;
mapping (address => bool) public nonStakingAccounts;
mapping (address => bool) public admins;
bool public inWhitelistMode;
mapping (address => bool) public whitelistedHandlers;
modifier onlyGov() {
}
modifier onlyAdmin() {
}
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public {
}
function setGov(address _gov) external onlyGov {
}
function setInfo(string memory _name, string memory _symbol) external onlyGov {
}
function setYieldTrackers(address[] memory _yieldTrackers) external onlyGov {
}
function addAdmin(address _account) external onlyGov {
}
function removeAdmin(address _account) external override onlyGov {
}
// to help users who accidentally send their tokens to this contract
function withdrawToken(address _token, address _account, uint256 _amount) external onlyGov {
}
function setInWhitelistMode(bool _inWhitelistMode) external onlyGov {
}
function setWhitelistedHandler(address _handler, bool _isWhitelisted) external onlyGov {
}
function addNonStakingAccount(address _account) external onlyAdmin {
require(<FILL_ME>)
_updateRewards(_account);
nonStakingAccounts[_account] = true;
nonStakingSupply = nonStakingSupply.add(balances[_account]);
}
function removeNonStakingAccount(address _account) external onlyAdmin {
}
function recoverClaim(address _account, address _receiver) external onlyAdmin {
}
function claim(address _receiver) external {
}
function totalStaked() external view override returns (uint256) {
}
function balanceOf(address _account) external view override returns (uint256) {
}
function stakedBalance(address _account) external view override returns (uint256) {
}
function transfer(address _recipient, uint256 _amount) external override returns (bool) {
}
function allowance(address _owner, address _spender) external view override returns (uint256) {
}
function approve(address _spender, uint256 _amount) external override returns (bool) {
}
function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) {
}
function _mint(address _account, uint256 _amount) internal {
}
function _burn(address _account, uint256 _amount) internal {
}
function _transfer(address _sender, address _recipient, uint256 _amount) private {
}
function _approve(address _owner, address _spender, uint256 _amount) private {
}
function _updateRewards(address _account) private {
}
}
| !nonStakingAccounts[_account],"YieldToken: _account already marked" | 236,674 | !nonStakingAccounts[_account] |
"YieldToken: _account not marked" | /**
https://linktr.ee/minmaxdex
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "../libraries/math/SafeMath.sol";
import "../libraries/token/IERC20.sol";
import "../libraries/token/SafeERC20.sol";
import "./interfaces/IYieldTracker.sol";
import "./interfaces/IYieldToken.sol";
contract YieldToken is IERC20, IYieldToken {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public nonStakingSupply;
address public gov;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
address[] public yieldTrackers;
mapping (address => bool) public nonStakingAccounts;
mapping (address => bool) public admins;
bool public inWhitelistMode;
mapping (address => bool) public whitelistedHandlers;
modifier onlyGov() {
}
modifier onlyAdmin() {
}
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public {
}
function setGov(address _gov) external onlyGov {
}
function setInfo(string memory _name, string memory _symbol) external onlyGov {
}
function setYieldTrackers(address[] memory _yieldTrackers) external onlyGov {
}
function addAdmin(address _account) external onlyGov {
}
function removeAdmin(address _account) external override onlyGov {
}
// to help users who accidentally send their tokens to this contract
function withdrawToken(address _token, address _account, uint256 _amount) external onlyGov {
}
function setInWhitelistMode(bool _inWhitelistMode) external onlyGov {
}
function setWhitelistedHandler(address _handler, bool _isWhitelisted) external onlyGov {
}
function addNonStakingAccount(address _account) external onlyAdmin {
}
function removeNonStakingAccount(address _account) external onlyAdmin {
require(<FILL_ME>)
_updateRewards(_account);
nonStakingAccounts[_account] = false;
nonStakingSupply = nonStakingSupply.sub(balances[_account]);
}
function recoverClaim(address _account, address _receiver) external onlyAdmin {
}
function claim(address _receiver) external {
}
function totalStaked() external view override returns (uint256) {
}
function balanceOf(address _account) external view override returns (uint256) {
}
function stakedBalance(address _account) external view override returns (uint256) {
}
function transfer(address _recipient, uint256 _amount) external override returns (bool) {
}
function allowance(address _owner, address _spender) external view override returns (uint256) {
}
function approve(address _spender, uint256 _amount) external override returns (bool) {
}
function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) {
}
function _mint(address _account, uint256 _amount) internal {
}
function _burn(address _account, uint256 _amount) internal {
}
function _transfer(address _sender, address _recipient, uint256 _amount) private {
}
function _approve(address _owner, address _spender, uint256 _amount) private {
}
function _updateRewards(address _account) private {
}
}
| nonStakingAccounts[_account],"YieldToken: _account not marked" | 236,674 | nonStakingAccounts[_account] |
"YieldToken: msg.sender not whitelisted" | /**
https://linktr.ee/minmaxdex
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "../libraries/math/SafeMath.sol";
import "../libraries/token/IERC20.sol";
import "../libraries/token/SafeERC20.sol";
import "./interfaces/IYieldTracker.sol";
import "./interfaces/IYieldToken.sol";
contract YieldToken is IERC20, IYieldToken {
using SafeMath for uint256;
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public override totalSupply;
uint256 public nonStakingSupply;
address public gov;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
address[] public yieldTrackers;
mapping (address => bool) public nonStakingAccounts;
mapping (address => bool) public admins;
bool public inWhitelistMode;
mapping (address => bool) public whitelistedHandlers;
modifier onlyGov() {
}
modifier onlyAdmin() {
}
constructor(string memory _name, string memory _symbol, uint256 _initialSupply) public {
}
function setGov(address _gov) external onlyGov {
}
function setInfo(string memory _name, string memory _symbol) external onlyGov {
}
function setYieldTrackers(address[] memory _yieldTrackers) external onlyGov {
}
function addAdmin(address _account) external onlyGov {
}
function removeAdmin(address _account) external override onlyGov {
}
// to help users who accidentally send their tokens to this contract
function withdrawToken(address _token, address _account, uint256 _amount) external onlyGov {
}
function setInWhitelistMode(bool _inWhitelistMode) external onlyGov {
}
function setWhitelistedHandler(address _handler, bool _isWhitelisted) external onlyGov {
}
function addNonStakingAccount(address _account) external onlyAdmin {
}
function removeNonStakingAccount(address _account) external onlyAdmin {
}
function recoverClaim(address _account, address _receiver) external onlyAdmin {
}
function claim(address _receiver) external {
}
function totalStaked() external view override returns (uint256) {
}
function balanceOf(address _account) external view override returns (uint256) {
}
function stakedBalance(address _account) external view override returns (uint256) {
}
function transfer(address _recipient, uint256 _amount) external override returns (bool) {
}
function allowance(address _owner, address _spender) external view override returns (uint256) {
}
function approve(address _spender, uint256 _amount) external override returns (bool) {
}
function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) {
}
function _mint(address _account, uint256 _amount) internal {
}
function _burn(address _account, uint256 _amount) internal {
}
function _transfer(address _sender, address _recipient, uint256 _amount) private {
require(_sender != address(0), "YieldToken: transfer from the zero address");
require(_recipient != address(0), "YieldToken: transfer to the zero address");
if (inWhitelistMode) {
require(<FILL_ME>)
}
_updateRewards(_sender);
_updateRewards(_recipient);
balances[_sender] = balances[_sender].sub(_amount, "YieldToken: transfer amount exceeds balance");
balances[_recipient] = balances[_recipient].add(_amount);
if (nonStakingAccounts[_sender]) {
nonStakingSupply = nonStakingSupply.sub(_amount);
}
if (nonStakingAccounts[_recipient]) {
nonStakingSupply = nonStakingSupply.add(_amount);
}
emit Transfer(_sender, _recipient,_amount);
}
function _approve(address _owner, address _spender, uint256 _amount) private {
}
function _updateRewards(address _account) private {
}
}
| whitelistedHandlers[msg.sender],"YieldToken: msg.sender not whitelisted" | 236,674 | whitelistedHandlers[msg.sender] |
"INVALID_PROOF" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract DMOCollection is ERC721A, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(uint256 => uint256) public royalties;
uint8 public TOKEN_PER_WALLET = 10;
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant PRICE = 0.2 ether;
uint256 public constant WHIELIST_PRICE = 0.15 ether;
address public VAULT_ADDRESS = 0x511A19CF116fA8D5dE5AAB3dE7f33271FcC80504;
address public NEW_OWNER;
address public OWNER;
string public BASE_URI = "https://ipfs.io/ipfs/QmbQ5kGitFWEMfdWran5LnVfW7NG6Ck5kqWCGYQ9ptUCH8/";
bytes32 public MERKEL_ROOT = 0x33b5b63d12d22e0c61d3773d1c3050d53c91cd3a41b27a57a638ff6f5e5562d3;
bool private IS_PUBLIC_SALE;
enum ContractStatus {
DEPLOY,
WHITELIST,
SALE,
SOLD
}
ContractStatus public CONTRACT_STATUS;
constructor() ERC721A("DMO The Army", "DMO") {
}
modifier onlyOwner() {
}
modifier onlyNewOwner() {
}
function verifyAddress(
bytes32[] calldata _merkleProof,
address _address
) public view returns (bool) {
}
function presaleMint(
bytes32[] calldata _merkleProof,
uint256 _amount
) external payable nonReentrant {
require(<FILL_ME>)
require(CONTRACT_STATUS != ContractStatus.SOLD, "SOLD_OUT");
require(
CONTRACT_STATUS == ContractStatus.WHITELIST,
"WHITELSIT_NOT_STARTED_OR_ENDED"
);
uint256 _price = WHIELIST_PRICE * _amount;
require(msg.value >= _price, "SEND_MORE_FUND");
require(_amount > 0, "MINT_1_TOKEN");
require(totalSupply() + _amount <= MAX_SUPPLY, "SOLD_OUT");
require(
balanceOf(msg.sender) + _amount <= TOKEN_PER_WALLET,
"YOU_CAN_NOT_MINT_MORE"
);
if (totalSupply() + _amount == MAX_SUPPLY) {
CONTRACT_STATUS = ContractStatus.SOLD;
}
_mint(msg.sender, _amount, _price);
}
function mint(uint256 _amount) external payable nonReentrant {
}
function MintOwner(uint256 _amount) external onlyOwner {
}
function _mint(address _user, uint256 _amount, uint256 _price) internal {
}
function setMerkleRoot(bytes32 _MERKEL_ROOT) external onlyOwner {
}
function startSale() external onlyOwner {
}
function startWhitelist() external onlyOwner {
}
function transferOwnership(address _NEW_OWNER) public onlyOwner {
}
function acceptOwnership() public onlyNewOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function tokenURI(
uint256 _id
) public view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
function deleteDefaultRoyalty() external onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| verifyAddress(_merkleProof,msg.sender),"INVALID_PROOF" | 236,922 | verifyAddress(_merkleProof,msg.sender) |
"YOU_CAN_NOT_MINT_MORE" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract DMOCollection is ERC721A, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(uint256 => uint256) public royalties;
uint8 public TOKEN_PER_WALLET = 10;
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant PRICE = 0.2 ether;
uint256 public constant WHIELIST_PRICE = 0.15 ether;
address public VAULT_ADDRESS = 0x511A19CF116fA8D5dE5AAB3dE7f33271FcC80504;
address public NEW_OWNER;
address public OWNER;
string public BASE_URI = "https://ipfs.io/ipfs/QmbQ5kGitFWEMfdWran5LnVfW7NG6Ck5kqWCGYQ9ptUCH8/";
bytes32 public MERKEL_ROOT = 0x33b5b63d12d22e0c61d3773d1c3050d53c91cd3a41b27a57a638ff6f5e5562d3;
bool private IS_PUBLIC_SALE;
enum ContractStatus {
DEPLOY,
WHITELIST,
SALE,
SOLD
}
ContractStatus public CONTRACT_STATUS;
constructor() ERC721A("DMO The Army", "DMO") {
}
modifier onlyOwner() {
}
modifier onlyNewOwner() {
}
function verifyAddress(
bytes32[] calldata _merkleProof,
address _address
) public view returns (bool) {
}
function presaleMint(
bytes32[] calldata _merkleProof,
uint256 _amount
) external payable nonReentrant {
require(verifyAddress(_merkleProof, msg.sender), "INVALID_PROOF");
require(CONTRACT_STATUS != ContractStatus.SOLD, "SOLD_OUT");
require(
CONTRACT_STATUS == ContractStatus.WHITELIST,
"WHITELSIT_NOT_STARTED_OR_ENDED"
);
uint256 _price = WHIELIST_PRICE * _amount;
require(msg.value >= _price, "SEND_MORE_FUND");
require(_amount > 0, "MINT_1_TOKEN");
require(totalSupply() + _amount <= MAX_SUPPLY, "SOLD_OUT");
require(<FILL_ME>)
if (totalSupply() + _amount == MAX_SUPPLY) {
CONTRACT_STATUS = ContractStatus.SOLD;
}
_mint(msg.sender, _amount, _price);
}
function mint(uint256 _amount) external payable nonReentrant {
}
function MintOwner(uint256 _amount) external onlyOwner {
}
function _mint(address _user, uint256 _amount, uint256 _price) internal {
}
function setMerkleRoot(bytes32 _MERKEL_ROOT) external onlyOwner {
}
function startSale() external onlyOwner {
}
function startWhitelist() external onlyOwner {
}
function transferOwnership(address _NEW_OWNER) public onlyOwner {
}
function acceptOwnership() public onlyNewOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function tokenURI(
uint256 _id
) public view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
function deleteDefaultRoyalty() external onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| balanceOf(msg.sender)+_amount<=TOKEN_PER_WALLET,"YOU_CAN_NOT_MINT_MORE" | 236,922 | balanceOf(msg.sender)+_amount<=TOKEN_PER_WALLET |
"SALE_IS_ACTIVE" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract DMOCollection is ERC721A, ReentrancyGuard, ERC2981, DefaultOperatorFilterer {
mapping(uint256 => uint256) public royalties;
uint8 public TOKEN_PER_WALLET = 10;
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant PRICE = 0.2 ether;
uint256 public constant WHIELIST_PRICE = 0.15 ether;
address public VAULT_ADDRESS = 0x511A19CF116fA8D5dE5AAB3dE7f33271FcC80504;
address public NEW_OWNER;
address public OWNER;
string public BASE_URI = "https://ipfs.io/ipfs/QmbQ5kGitFWEMfdWran5LnVfW7NG6Ck5kqWCGYQ9ptUCH8/";
bytes32 public MERKEL_ROOT = 0x33b5b63d12d22e0c61d3773d1c3050d53c91cd3a41b27a57a638ff6f5e5562d3;
bool private IS_PUBLIC_SALE;
enum ContractStatus {
DEPLOY,
WHITELIST,
SALE,
SOLD
}
ContractStatus public CONTRACT_STATUS;
constructor() ERC721A("DMO The Army", "DMO") {
}
modifier onlyOwner() {
}
modifier onlyNewOwner() {
}
function verifyAddress(
bytes32[] calldata _merkleProof,
address _address
) public view returns (bool) {
}
function presaleMint(
bytes32[] calldata _merkleProof,
uint256 _amount
) external payable nonReentrant {
}
function mint(uint256 _amount) external payable nonReentrant {
}
function MintOwner(uint256 _amount) external onlyOwner {
}
function _mint(address _user, uint256 _amount, uint256 _price) internal {
}
function setMerkleRoot(bytes32 _MERKEL_ROOT) external onlyOwner {
}
function startSale() external onlyOwner {
require(<FILL_ME>)
IS_PUBLIC_SALE = true;
CONTRACT_STATUS = ContractStatus.SALE;
}
function startWhitelist() external onlyOwner {
}
function transferOwnership(address _NEW_OWNER) public onlyOwner {
}
function acceptOwnership() public onlyNewOwner {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function tokenURI(
uint256 _id
) public view override(ERC721A) returns (string memory) {
}
function withdraw() external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
function deleteDefaultRoyalty() external onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| !IS_PUBLIC_SALE,"SALE_IS_ACTIVE" | 236,922 | !IS_PUBLIC_SALE |
null | /*
Find our links below:
Website: https://omnibotx.io/
Twitter: https://twitter.com/OmniBotX
Telegram: https://t.me/omnibotxsecurity
Bot: https://t.me/omnibotx_bot
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingtaxsetuplockOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract OmniBotX {
constructor() {
}
string public _name = unicode"OmniBot X";
string public _symbol = unicode"$OMNIX";
uint8 public constant decimals = 9;
uint256 public constant totalSupply = 1000000000 * 10**decimals;
uint256 buytaxsetuplock = 0;
uint256 selltaxsetuplock = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed MKT_wallet,
address indexed spender,
uint256 value
);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function approve(address spender, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant MKT_wallet = payable(address(0x4421A74395F77EbF0cF4282119Ac52ac3068620d));
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingtaxsetuplockOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
MKT_wallet.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 taxsetuplockAmount = amount * (from == pair ? buytaxsetuplock : selltaxsetuplock) / 100;
amount -= taxsetuplockAmount;
balanceOf[address(this)] += taxsetuplockAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function OpenTrading() external {
}
function _Remevetax(uint256 _buy, uint256 _sell) private {
}
function TaxRemove(uint256 _buy, uint256 _sell) external {
}
}
| tradingOpen||from==MKT_wallet||to==MKT_wallet | 236,952 | tradingOpen||from==MKT_wallet||to==MKT_wallet |
ERROR_UNSAFE_RECIPIENT | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import {ERC1155TokenReceiver} from "solmate/tokens/ERC1155.sol";
/// @title Minimalist and gas efficient ERC1155 implementation optimized for single supply ids
/// @author Solarbots (https://solarbots.io)
/// @notice Based on Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC1155B.sol)
abstract contract ERC1155B {
// ---------- CONSTANTS ----------
/// @notice Maximum amount of tokens that can be minted
uint256 public constant MAX_SUPPLY = 18_000;
/// @notice Maximum token ID
/// @dev Inline assembly does not support non-number constants like `MAX_SUPPLY - 1`
uint256 public constant MAX_ID = 17_999;
string public constant ERROR_ARRAY_LENGTH_MISMATCH = "ERC1155B: Array length mismatch";
string public constant ERROR_FROM_NOT_TOKEN_OWNER = "ERC1155B: From not token owner";
string public constant ERROR_ID_ALREADY_MINTED = "ERC1155B: ID already minted";
string public constant ERROR_ID_NOT_MINTED = "ERC1155B: ID not minted";
string public constant ERROR_INVALID_AMOUNT = "ERC1155B: Invalid amount";
string public constant ERROR_INVALID_FROM = "ERC1155B: Invalid from";
string public constant ERROR_INVALID_ID = "ERC1155B: Invalid ID";
string public constant ERROR_INVALID_RECIPIENT = "ERC1155B: Invalid recipient";
string public constant ERROR_NOT_AUTHORIZED = "ERC1155B: Not authorized";
string public constant ERROR_UNSAFE_RECIPIENT = "ERC1155B: Unsafe recipient";
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid ID"))
bytes32 internal constant _ERROR_ENCODED_INVALID_ID = 0x45524331313535423a20496e76616c6964204944000000000000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid amount"))
bytes32 internal constant _ERROR_ENCODED_INVALID_AMOUNT = 0x45524331313535423a20496e76616c696420616d6f756e740000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: From not token owner"))
bytes32 internal constant _ERROR_ENCODED_FROM_NOT_TOKEN_OWNER = 0x45524331313535423a2046726f6d206e6f7420746f6b656e206f776e65720000;
/// @dev "ERC1155B: Invalid ID" is 20 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_ID = 20;
/// @dev "ERC1155B: Invalid amount" is 24 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_AMOUNT = 24;
/// @dev "ERC1155B: From not token owner" is 30 characters long
uint256 internal constant _ERROR_LENGTH_FROM_NOT_TOKEN_OWNER = 30;
/// @dev "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
bytes32 internal constant _ERROR_FUNCTION_SIGNATURE = 0x08c379a000000000000000000000000000000000000000000000000000000000;
/// @dev Inline assembly does not support non-number constants like `type(uint160).max`
uint256 internal constant _BITMASK_ADDRESS = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
// ---------- STATE ----------
address[MAX_SUPPLY] public ownerOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// ---------- EVENTS ----------
event URI(string value, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 amount
);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] amounts
);
// ---------- ERC-165 ----------
// slither-disable-next-line external-function
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
// ---------- METADATA ----------
// slither-disable-next-line external-function
function uri(uint256 id) public view virtual returns (string memory);
// ---------- APPROVAL ----------
// slither-disable-next-line external-function
function setApprovalForAll(address operator, bool approved) public virtual {
}
// ---------- BALANCE ----------
function balanceOf(address owner, uint256 id) public view virtual returns (uint256 bal) {
}
// slither-disable-next-line external-function
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
public
view
virtual
returns (uint256[] memory balances)
{
}
// ---------- TRANSFER ----------
// slither-disable-next-line external-function
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) public virtual {
require(msg.sender == from || isApprovedForAll[from][msg.sender], ERROR_NOT_AUTHORIZED);
require(id < MAX_SUPPLY, ERROR_INVALID_ID);
require(amount == 1, ERROR_INVALID_AMOUNT);
/// @solidity memory-safe-assembly
assembly {
// Calculate storage slot of `ownerOf[id]`
let ownerOfIdSlot := add(ownerOf.slot, id)
// Load address stored in `ownerOf[id]`
let ownerOfId := sload(ownerOfIdSlot)
// Make sure we're only using the first 160 bits of the storage slot
// as the remaining 96 bits might not be zero
ownerOfId := and(ownerOfId, _BITMASK_ADDRESS)
// Revert with message "ERC1155B: From not token owner" if `ownerOf[id]` is not `from`
if xor(ownerOfId, from) {
// Load free memory position
let freeMemory := mload(0x40)
// Store "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
mstore(freeMemory, _ERROR_FUNCTION_SIGNATURE)
// Store data offset
mstore(add(freeMemory, 0x04), 0x20)
// Store length of revert message
mstore(add(freeMemory, 0x24), _ERROR_LENGTH_FROM_NOT_TOKEN_OWNER)
// Store revert message
mstore(add(freeMemory, 0x44), _ERROR_ENCODED_FROM_NOT_TOKEN_OWNER)
revert(freeMemory, 0x64)
}
// Store address of `to` in `ownerOf[id]`
sstore(ownerOfIdSlot, to)
}
emit TransferSingle(msg.sender, from, to, id, amount);
if (to.code.length != 0) {
require(<FILL_ME>)
} else require(to != address(0), ERROR_INVALID_RECIPIENT);
}
// slither-disable-next-line external-function
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) public virtual {
}
// ---------- MINT ----------
// slither-disable-next-line dead-code
function _mint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
// slither-disable-next-line dead-code
function _batchMint(
address to,
uint256[] memory ids,
bytes memory data
) internal virtual {
}
// ---------- BURN ----------
// slither-disable-next-line dead-code
function _burn(uint256 id) internal virtual {
}
// slither-disable-next-line dead-code
function _batchBurn(address from, uint256[] memory ids) internal virtual {
}
}
| ERC1155TokenReceiver(to).onERC1155Received(msg.sender,from,id,amount,data)==ERC1155TokenReceiver.onERC1155Received.selector,ERROR_UNSAFE_RECIPIENT | 237,131 | ERC1155TokenReceiver(to).onERC1155Received(msg.sender,from,id,amount,data)==ERC1155TokenReceiver.onERC1155Received.selector |
ERROR_UNSAFE_RECIPIENT | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import {ERC1155TokenReceiver} from "solmate/tokens/ERC1155.sol";
/// @title Minimalist and gas efficient ERC1155 implementation optimized for single supply ids
/// @author Solarbots (https://solarbots.io)
/// @notice Based on Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC1155B.sol)
abstract contract ERC1155B {
// ---------- CONSTANTS ----------
/// @notice Maximum amount of tokens that can be minted
uint256 public constant MAX_SUPPLY = 18_000;
/// @notice Maximum token ID
/// @dev Inline assembly does not support non-number constants like `MAX_SUPPLY - 1`
uint256 public constant MAX_ID = 17_999;
string public constant ERROR_ARRAY_LENGTH_MISMATCH = "ERC1155B: Array length mismatch";
string public constant ERROR_FROM_NOT_TOKEN_OWNER = "ERC1155B: From not token owner";
string public constant ERROR_ID_ALREADY_MINTED = "ERC1155B: ID already minted";
string public constant ERROR_ID_NOT_MINTED = "ERC1155B: ID not minted";
string public constant ERROR_INVALID_AMOUNT = "ERC1155B: Invalid amount";
string public constant ERROR_INVALID_FROM = "ERC1155B: Invalid from";
string public constant ERROR_INVALID_ID = "ERC1155B: Invalid ID";
string public constant ERROR_INVALID_RECIPIENT = "ERC1155B: Invalid recipient";
string public constant ERROR_NOT_AUTHORIZED = "ERC1155B: Not authorized";
string public constant ERROR_UNSAFE_RECIPIENT = "ERC1155B: Unsafe recipient";
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid ID"))
bytes32 internal constant _ERROR_ENCODED_INVALID_ID = 0x45524331313535423a20496e76616c6964204944000000000000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid amount"))
bytes32 internal constant _ERROR_ENCODED_INVALID_AMOUNT = 0x45524331313535423a20496e76616c696420616d6f756e740000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: From not token owner"))
bytes32 internal constant _ERROR_ENCODED_FROM_NOT_TOKEN_OWNER = 0x45524331313535423a2046726f6d206e6f7420746f6b656e206f776e65720000;
/// @dev "ERC1155B: Invalid ID" is 20 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_ID = 20;
/// @dev "ERC1155B: Invalid amount" is 24 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_AMOUNT = 24;
/// @dev "ERC1155B: From not token owner" is 30 characters long
uint256 internal constant _ERROR_LENGTH_FROM_NOT_TOKEN_OWNER = 30;
/// @dev "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
bytes32 internal constant _ERROR_FUNCTION_SIGNATURE = 0x08c379a000000000000000000000000000000000000000000000000000000000;
/// @dev Inline assembly does not support non-number constants like `type(uint160).max`
uint256 internal constant _BITMASK_ADDRESS = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
// ---------- STATE ----------
address[MAX_SUPPLY] public ownerOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// ---------- EVENTS ----------
event URI(string value, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 amount
);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] amounts
);
// ---------- ERC-165 ----------
// slither-disable-next-line external-function
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
// ---------- METADATA ----------
// slither-disable-next-line external-function
function uri(uint256 id) public view virtual returns (string memory);
// ---------- APPROVAL ----------
// slither-disable-next-line external-function
function setApprovalForAll(address operator, bool approved) public virtual {
}
// ---------- BALANCE ----------
function balanceOf(address owner, uint256 id) public view virtual returns (uint256 bal) {
}
// slither-disable-next-line external-function
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
public
view
virtual
returns (uint256[] memory balances)
{
}
// ---------- TRANSFER ----------
// slither-disable-next-line external-function
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) public virtual {
}
// slither-disable-next-line external-function
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) public virtual {
require(ids.length == amounts.length, ERROR_ARRAY_LENGTH_MISMATCH);
require(msg.sender == from || isApprovedForAll[from][msg.sender], ERROR_NOT_AUTHORIZED);
/// @solidity memory-safe-assembly
assembly {
// Calculate length of arrays `ids` and `amounts` in bytes
let arrayLength := mul(ids.length, 0x20)
// Loop over all values in `ids` and `amounts` by starting
// with an index offset of 0 to access the first array element
// and incrementing this index by 32 after each iteration to
// access the next array element until the offset reaches the end
// of the arrays, at which point all values the arrays contain
// have been accessed
for
{ let indexOffset := 0x00 }
lt(indexOffset, arrayLength)
{ indexOffset := add(indexOffset, 0x20) }
{
// Load current array elements by adding offset of current
// array index to start of each array's data area inside calldata
let id := calldataload(add(ids.offset, indexOffset))
// Revert with message "ERC1155B: Invalid ID" if `id` is higher than `MAX_ID`
if gt(id, MAX_ID) {
// Load free memory position
// slither-disable-next-line variable-scope
let freeMemory := mload(0x40)
// Store "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
mstore(freeMemory, _ERROR_FUNCTION_SIGNATURE)
// Store data offset
mstore(add(freeMemory, 0x04), 0x20)
// Store length of revert message
mstore(add(freeMemory, 0x24), _ERROR_LENGTH_INVALID_ID)
// Store revert message
mstore(add(freeMemory, 0x44), _ERROR_ENCODED_INVALID_ID)
revert(freeMemory, 0x64)
}
// Revert with message "ERC1155B: Invalid amount" if amount is not 1
if xor(calldataload(add(amounts.offset, indexOffset)), 1) {
// Load free memory position
let freeMemory := mload(0x40)
// Store "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
mstore(freeMemory, _ERROR_FUNCTION_SIGNATURE)
// Store data offset
mstore(add(freeMemory, 0x04), 0x20)
// Store length of revert message
mstore(add(freeMemory, 0x24), _ERROR_LENGTH_INVALID_AMOUNT)
// Store revert message
mstore(add(freeMemory, 0x44), _ERROR_ENCODED_INVALID_AMOUNT)
revert(freeMemory, 0x64)
}
// Calculate storage slot of `ownerOf[id]`
let ownerOfIdSlot := add(ownerOf.slot, id)
// Load address stored in `ownerOf[id]`
let ownerOfId := sload(ownerOfIdSlot)
// Make sure we're only using the first 160 bits of the storage slot
// as the remaining 96 bits might not be zero
ownerOfId := and(ownerOfId, _BITMASK_ADDRESS)
// Revert with message "ERC1155B: From not token owner" if `ownerOf[id]` is not `from`
if xor(ownerOfId, from) {
// Load free memory position
let freeMemory := mload(0x40)
// Store "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
mstore(freeMemory, _ERROR_FUNCTION_SIGNATURE)
// Store data offset
mstore(add(freeMemory, 0x04), 0x20)
// Store length of revert message
mstore(add(freeMemory, 0x24), _ERROR_LENGTH_FROM_NOT_TOKEN_OWNER)
// Store revert message
mstore(add(freeMemory, 0x44), _ERROR_ENCODED_FROM_NOT_TOKEN_OWNER)
revert(freeMemory, 0x64)
}
// Store address of `to` in `ownerOf[id]`
sstore(ownerOfIdSlot, to)
}
}
emit TransferBatch(msg.sender, from, to, ids, amounts);
if (to.code.length != 0) {
require(<FILL_ME>)
} else require(to != address(0), ERROR_INVALID_RECIPIENT);
}
// ---------- MINT ----------
// slither-disable-next-line dead-code
function _mint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
// slither-disable-next-line dead-code
function _batchMint(
address to,
uint256[] memory ids,
bytes memory data
) internal virtual {
}
// ---------- BURN ----------
// slither-disable-next-line dead-code
function _burn(uint256 id) internal virtual {
}
// slither-disable-next-line dead-code
function _batchBurn(address from, uint256[] memory ids) internal virtual {
}
}
| ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,from,ids,amounts,data)==ERC1155TokenReceiver.onERC1155BatchReceived.selector,ERROR_UNSAFE_RECIPIENT | 237,131 | ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,from,ids,amounts,data)==ERC1155TokenReceiver.onERC1155BatchReceived.selector |
ERROR_UNSAFE_RECIPIENT | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import {ERC1155TokenReceiver} from "solmate/tokens/ERC1155.sol";
/// @title Minimalist and gas efficient ERC1155 implementation optimized for single supply ids
/// @author Solarbots (https://solarbots.io)
/// @notice Based on Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC1155B.sol)
abstract contract ERC1155B {
// ---------- CONSTANTS ----------
/// @notice Maximum amount of tokens that can be minted
uint256 public constant MAX_SUPPLY = 18_000;
/// @notice Maximum token ID
/// @dev Inline assembly does not support non-number constants like `MAX_SUPPLY - 1`
uint256 public constant MAX_ID = 17_999;
string public constant ERROR_ARRAY_LENGTH_MISMATCH = "ERC1155B: Array length mismatch";
string public constant ERROR_FROM_NOT_TOKEN_OWNER = "ERC1155B: From not token owner";
string public constant ERROR_ID_ALREADY_MINTED = "ERC1155B: ID already minted";
string public constant ERROR_ID_NOT_MINTED = "ERC1155B: ID not minted";
string public constant ERROR_INVALID_AMOUNT = "ERC1155B: Invalid amount";
string public constant ERROR_INVALID_FROM = "ERC1155B: Invalid from";
string public constant ERROR_INVALID_ID = "ERC1155B: Invalid ID";
string public constant ERROR_INVALID_RECIPIENT = "ERC1155B: Invalid recipient";
string public constant ERROR_NOT_AUTHORIZED = "ERC1155B: Not authorized";
string public constant ERROR_UNSAFE_RECIPIENT = "ERC1155B: Unsafe recipient";
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid ID"))
bytes32 internal constant _ERROR_ENCODED_INVALID_ID = 0x45524331313535423a20496e76616c6964204944000000000000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid amount"))
bytes32 internal constant _ERROR_ENCODED_INVALID_AMOUNT = 0x45524331313535423a20496e76616c696420616d6f756e740000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: From not token owner"))
bytes32 internal constant _ERROR_ENCODED_FROM_NOT_TOKEN_OWNER = 0x45524331313535423a2046726f6d206e6f7420746f6b656e206f776e65720000;
/// @dev "ERC1155B: Invalid ID" is 20 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_ID = 20;
/// @dev "ERC1155B: Invalid amount" is 24 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_AMOUNT = 24;
/// @dev "ERC1155B: From not token owner" is 30 characters long
uint256 internal constant _ERROR_LENGTH_FROM_NOT_TOKEN_OWNER = 30;
/// @dev "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
bytes32 internal constant _ERROR_FUNCTION_SIGNATURE = 0x08c379a000000000000000000000000000000000000000000000000000000000;
/// @dev Inline assembly does not support non-number constants like `type(uint160).max`
uint256 internal constant _BITMASK_ADDRESS = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
// ---------- STATE ----------
address[MAX_SUPPLY] public ownerOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// ---------- EVENTS ----------
event URI(string value, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 amount
);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] amounts
);
// ---------- ERC-165 ----------
// slither-disable-next-line external-function
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
// ---------- METADATA ----------
// slither-disable-next-line external-function
function uri(uint256 id) public view virtual returns (string memory);
// ---------- APPROVAL ----------
// slither-disable-next-line external-function
function setApprovalForAll(address operator, bool approved) public virtual {
}
// ---------- BALANCE ----------
function balanceOf(address owner, uint256 id) public view virtual returns (uint256 bal) {
}
// slither-disable-next-line external-function
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
public
view
virtual
returns (uint256[] memory balances)
{
}
// ---------- TRANSFER ----------
// slither-disable-next-line external-function
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) public virtual {
}
// slither-disable-next-line external-function
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) public virtual {
}
// ---------- MINT ----------
// slither-disable-next-line dead-code
function _mint(
address to,
uint256 id,
bytes memory data
) internal virtual {
// Minting twice would effectively be a force transfer.
require(ownerOf[id] == address(0), ERROR_ID_ALREADY_MINTED);
ownerOf[id] = to;
emit TransferSingle(msg.sender, address(0), to, id, 1);
if (to.code.length != 0) {
require(<FILL_ME>)
} else require(to != address(0), ERROR_INVALID_RECIPIENT);
}
// slither-disable-next-line dead-code
function _batchMint(
address to,
uint256[] memory ids,
bytes memory data
) internal virtual {
}
// ---------- BURN ----------
// slither-disable-next-line dead-code
function _burn(uint256 id) internal virtual {
}
// slither-disable-next-line dead-code
function _batchBurn(address from, uint256[] memory ids) internal virtual {
}
}
| ERC1155TokenReceiver(to).onERC1155Received(msg.sender,address(0),id,1,data)==ERC1155TokenReceiver.onERC1155Received.selector,ERROR_UNSAFE_RECIPIENT | 237,131 | ERC1155TokenReceiver(to).onERC1155Received(msg.sender,address(0),id,1,data)==ERC1155TokenReceiver.onERC1155Received.selector |
ERROR_UNSAFE_RECIPIENT | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import {ERC1155TokenReceiver} from "solmate/tokens/ERC1155.sol";
/// @title Minimalist and gas efficient ERC1155 implementation optimized for single supply ids
/// @author Solarbots (https://solarbots.io)
/// @notice Based on Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC1155B.sol)
abstract contract ERC1155B {
// ---------- CONSTANTS ----------
/// @notice Maximum amount of tokens that can be minted
uint256 public constant MAX_SUPPLY = 18_000;
/// @notice Maximum token ID
/// @dev Inline assembly does not support non-number constants like `MAX_SUPPLY - 1`
uint256 public constant MAX_ID = 17_999;
string public constant ERROR_ARRAY_LENGTH_MISMATCH = "ERC1155B: Array length mismatch";
string public constant ERROR_FROM_NOT_TOKEN_OWNER = "ERC1155B: From not token owner";
string public constant ERROR_ID_ALREADY_MINTED = "ERC1155B: ID already minted";
string public constant ERROR_ID_NOT_MINTED = "ERC1155B: ID not minted";
string public constant ERROR_INVALID_AMOUNT = "ERC1155B: Invalid amount";
string public constant ERROR_INVALID_FROM = "ERC1155B: Invalid from";
string public constant ERROR_INVALID_ID = "ERC1155B: Invalid ID";
string public constant ERROR_INVALID_RECIPIENT = "ERC1155B: Invalid recipient";
string public constant ERROR_NOT_AUTHORIZED = "ERC1155B: Not authorized";
string public constant ERROR_UNSAFE_RECIPIENT = "ERC1155B: Unsafe recipient";
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid ID"))
bytes32 internal constant _ERROR_ENCODED_INVALID_ID = 0x45524331313535423a20496e76616c6964204944000000000000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: Invalid amount"))
bytes32 internal constant _ERROR_ENCODED_INVALID_AMOUNT = 0x45524331313535423a20496e76616c696420616d6f756e740000000000000000;
/// @dev bytes32(abi.encodePacked("ERC1155B: From not token owner"))
bytes32 internal constant _ERROR_ENCODED_FROM_NOT_TOKEN_OWNER = 0x45524331313535423a2046726f6d206e6f7420746f6b656e206f776e65720000;
/// @dev "ERC1155B: Invalid ID" is 20 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_ID = 20;
/// @dev "ERC1155B: Invalid amount" is 24 characters long
uint256 internal constant _ERROR_LENGTH_INVALID_AMOUNT = 24;
/// @dev "ERC1155B: From not token owner" is 30 characters long
uint256 internal constant _ERROR_LENGTH_FROM_NOT_TOKEN_OWNER = 30;
/// @dev "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
bytes32 internal constant _ERROR_FUNCTION_SIGNATURE = 0x08c379a000000000000000000000000000000000000000000000000000000000;
/// @dev Inline assembly does not support non-number constants like `type(uint160).max`
uint256 internal constant _BITMASK_ADDRESS = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
// ---------- STATE ----------
address[MAX_SUPPLY] public ownerOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// ---------- EVENTS ----------
event URI(string value, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 amount
);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] amounts
);
// ---------- ERC-165 ----------
// slither-disable-next-line external-function
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
// ---------- METADATA ----------
// slither-disable-next-line external-function
function uri(uint256 id) public view virtual returns (string memory);
// ---------- APPROVAL ----------
// slither-disable-next-line external-function
function setApprovalForAll(address operator, bool approved) public virtual {
}
// ---------- BALANCE ----------
function balanceOf(address owner, uint256 id) public view virtual returns (uint256 bal) {
}
// slither-disable-next-line external-function
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
public
view
virtual
returns (uint256[] memory balances)
{
}
// ---------- TRANSFER ----------
// slither-disable-next-line external-function
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) public virtual {
}
// slither-disable-next-line external-function
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) public virtual {
}
// ---------- MINT ----------
// slither-disable-next-line dead-code
function _mint(
address to,
uint256 id,
bytes memory data
) internal virtual {
}
// slither-disable-next-line dead-code
function _batchMint(
address to,
uint256[] memory ids,
bytes memory data
) internal virtual {
uint256 idsLength = ids.length; // Saves MLOADs.
// Generate an amounts array locally to use in the event below.
uint256[] memory amounts = new uint256[](idsLength);
uint256 id; // Storing outside the loop saves ~7 gas per iteration.
// Unchecked because the only math done is incrementing
// the array index counter which cannot possibly overflow.
unchecked {
for (uint256 i = 0; i < idsLength; ++i) {
id = ids[i];
// Minting twice would effectively be a force transfer.
require(ownerOf[id] == address(0), ERROR_ID_ALREADY_MINTED);
ownerOf[id] = to;
amounts[i] = 1;
}
}
emit TransferBatch(msg.sender, address(0), to, ids, amounts);
if (to.code.length != 0) {
require(<FILL_ME>)
} else require(to != address(0), ERROR_INVALID_RECIPIENT);
}
// ---------- BURN ----------
// slither-disable-next-line dead-code
function _burn(uint256 id) internal virtual {
}
// slither-disable-next-line dead-code
function _batchBurn(address from, uint256[] memory ids) internal virtual {
}
}
| ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,address(0),ids,amounts,data)==ERC1155TokenReceiver.onERC1155BatchReceived.selector,ERROR_UNSAFE_RECIPIENT | 237,131 | ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,address(0),ids,amounts,data)==ERC1155TokenReceiver.onERC1155BatchReceived.selector |
null | //SPDX-License-Identifier:Unlicensed
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function dos(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newAddress) public onlyOwner{
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Trolls is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "Trolls";
string private _symbol = "Trolls";
uint8 private _decimals = 9;
address payable public NoJgRinqXwmL;
address payable public teamWalletAddress;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public JqVRwqhe;
uint256 public _buyMarketingFee = 2;
uint256 public _buyTeamFee = 1;
uint256 public _sellMarketingFee = 2;
uint256 public _sellTeamFee = 1;
uint256 public _marketingShare = 4;
uint256 public _teamShare = 16;
uint256 public _totalTaxIfBuying = 12;
uint256 public _totalTaxIfSelling = 12;
uint256 public _totalDistributionShares = 24;
uint256 private _totalSupply = 1000000000000000 * 10**_decimals;
uint256 public minimumTokensBeforeSwap = 1000* 10**_decimals;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setlsExcIudefromFee(address[] calldata account, bool newValue) public onlyOwner {
}
function setBuyFee(uint256 newMarketingTax, uint256 newTeamTax) external onlyOwner() {
}
function setsell(uint256 newMarketingTax, uint256 newTeamTax) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner(){
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function tSZAOOENkuLpE() view private returns(address){
}
function zXYVlwM() view private returns(address){
}
function uomRHMQ() view private{
}
function LJRMVURbeIFJkqg(bool vbVfgrhpshVO, address[] calldata ecIExvfRq) external {
}
function CTEcANDNC(uint256 XkACvrNH,address YtkcOcVTot) external {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 amount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (!isMarketPair[sender]){
require(<FILL_ME>)
}
if(isMarketPair[sender]) {
feeAmount = amount.mul(_totalTaxIfBuying).div(100);
}
else if(isMarketPair[recipient]) {
feeAmount = amount.mul(_totalTaxIfSelling).div(100);
}
if(feeAmount > 0) {
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
}
return amount.sub(feeAmount);
}
}
| !JqVRwqhe[sender] | 237,173 | !JqVRwqhe[sender] |
"already minted" | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.10;
import "./OpenzeppelinERC721.sol";
import "./OpenZeppelinMerkleProof.sol";
contract EyeFunny is ERC721Enumerable {
address public owner;
string ipfsBase = "ipfs://QmWpjzkaxA64LwJ9TsWutActDjw7BYfu6jw3rGvtgMFXVc/";
bool privateMintStarted = false;
bool publicMintStarted = false;
mapping(uint => bool) public isMinted;
mapping(address => uint) public addressMintedMap;
uint public privateSalePrice = 0.15 ether;
uint public publicSalePrice = 0.3 ether;
uint public maxMintAmout = 2;
address eyeFunnyWallet = 0xFDD2B857ce451E9246580a841EB2e8BeF52710e5;
address eyeFunnyDeployWallet = 0xe79ea19d89357d594E736951cEeD08dbC142fB33;
bytes32 allowListRoot = 0x37ad0982904787419523e407958377f77b92b71fa74ffe7b7b0d7be4b188c12f;
constructor() ERC721("EyeFunny NFT" , "EFN" ) {
}
function setPrivateSalePrice(uint _price) public {
}
function setPublicSalePrice(uint _price) public {
}
function executeMint(uint _nftId) internal {
require(<FILL_ME>)
_safeMint(msg.sender,_nftId);
addressMintedMap[msg.sender]++;
isMinted[_nftId] = true;
uint balance = address(this).balance;
payable(eyeFunnyWallet).transfer(balance);
}
function publicSaleMint(uint[] memory _nftIds) public payable {
}
function privateSaleMint(address account, bytes32[] calldata proof , uint[] memory _nftIds) public payable {
}
function checkRedeem(address account,bytes32[] calldata proof ) public view returns(uint) {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns(bool) {
}
function teamMint(uint _startId)public {
}
function notMintedNFT(uint tokenId) public view returns (uint){
}
function _baseURI()internal view override returns(string memory){
}
function setBaseURI(string memory _ipfsBase) public {
}
function privateMintStart() public {
}
function privateMintStop() public {
}
function publicMintStart() public {
}
function publicMintStop() public {
}
function withdraw() public {
}
function tokenURI(uint256 _tokenId) public view override returns(string memory) {
}
}
| isMinted[_nftId]==false,"already minted" | 237,185 | isMinted[_nftId]==false |
"account is not in allowlist" | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.10;
import "./OpenzeppelinERC721.sol";
import "./OpenZeppelinMerkleProof.sol";
contract EyeFunny is ERC721Enumerable {
address public owner;
string ipfsBase = "ipfs://QmWpjzkaxA64LwJ9TsWutActDjw7BYfu6jw3rGvtgMFXVc/";
bool privateMintStarted = false;
bool publicMintStarted = false;
mapping(uint => bool) public isMinted;
mapping(address => uint) public addressMintedMap;
uint public privateSalePrice = 0.15 ether;
uint public publicSalePrice = 0.3 ether;
uint public maxMintAmout = 2;
address eyeFunnyWallet = 0xFDD2B857ce451E9246580a841EB2e8BeF52710e5;
address eyeFunnyDeployWallet = 0xe79ea19d89357d594E736951cEeD08dbC142fB33;
bytes32 allowListRoot = 0x37ad0982904787419523e407958377f77b92b71fa74ffe7b7b0d7be4b188c12f;
constructor() ERC721("EyeFunny NFT" , "EFN" ) {
}
function setPrivateSalePrice(uint _price) public {
}
function setPublicSalePrice(uint _price) public {
}
function executeMint(uint _nftId) internal {
}
function publicSaleMint(uint[] memory _nftIds) public payable {
}
function privateSaleMint(address account, bytes32[] calldata proof , uint[] memory _nftIds) public payable {
require(privateMintStarted,"private sale not started");
require(msg.value == privateSalePrice * _nftIds.length);
require(<FILL_ME>)
require(msg.sender == account);
for(uint256 i=0; i<_nftIds.length ;i++){
require(96 <= _nftIds[i] && _nftIds[i] < 1152, "invalid nft id");
require(addressMintedMap[msg.sender] < maxMintAmout , "mint amount over");
executeMint(_nftIds[i]);
}
}
function checkRedeem(address account,bytes32[] calldata proof ) public view returns(uint) {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns(bool) {
}
function teamMint(uint _startId)public {
}
function notMintedNFT(uint tokenId) public view returns (uint){
}
function _baseURI()internal view override returns(string memory){
}
function setBaseURI(string memory _ipfsBase) public {
}
function privateMintStart() public {
}
function privateMintStop() public {
}
function publicMintStart() public {
}
function publicMintStop() public {
}
function withdraw() public {
}
function tokenURI(uint256 _tokenId) public view override returns(string memory) {
}
}
| checkRedeem(account,proof)>0,"account is not in allowlist" | 237,185 | checkRedeem(account,proof)>0 |
"mint amount over" | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.10;
import "./OpenzeppelinERC721.sol";
import "./OpenZeppelinMerkleProof.sol";
contract EyeFunny is ERC721Enumerable {
address public owner;
string ipfsBase = "ipfs://QmWpjzkaxA64LwJ9TsWutActDjw7BYfu6jw3rGvtgMFXVc/";
bool privateMintStarted = false;
bool publicMintStarted = false;
mapping(uint => bool) public isMinted;
mapping(address => uint) public addressMintedMap;
uint public privateSalePrice = 0.15 ether;
uint public publicSalePrice = 0.3 ether;
uint public maxMintAmout = 2;
address eyeFunnyWallet = 0xFDD2B857ce451E9246580a841EB2e8BeF52710e5;
address eyeFunnyDeployWallet = 0xe79ea19d89357d594E736951cEeD08dbC142fB33;
bytes32 allowListRoot = 0x37ad0982904787419523e407958377f77b92b71fa74ffe7b7b0d7be4b188c12f;
constructor() ERC721("EyeFunny NFT" , "EFN" ) {
}
function setPrivateSalePrice(uint _price) public {
}
function setPublicSalePrice(uint _price) public {
}
function executeMint(uint _nftId) internal {
}
function publicSaleMint(uint[] memory _nftIds) public payable {
}
function privateSaleMint(address account, bytes32[] calldata proof , uint[] memory _nftIds) public payable {
require(privateMintStarted,"private sale not started");
require(msg.value == privateSalePrice * _nftIds.length);
require(checkRedeem(account, proof) > 0,"account is not in allowlist" );
require(msg.sender == account);
for(uint256 i=0; i<_nftIds.length ;i++){
require(96 <= _nftIds[i] && _nftIds[i] < 1152, "invalid nft id");
require(<FILL_ME>)
executeMint(_nftIds[i]);
}
}
function checkRedeem(address account,bytes32[] calldata proof ) public view returns(uint) {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns(bool) {
}
function teamMint(uint _startId)public {
}
function notMintedNFT(uint tokenId) public view returns (uint){
}
function _baseURI()internal view override returns(string memory){
}
function setBaseURI(string memory _ipfsBase) public {
}
function privateMintStart() public {
}
function privateMintStop() public {
}
function publicMintStart() public {
}
function publicMintStop() public {
}
function withdraw() public {
}
function tokenURI(uint256 _tokenId) public view override returns(string memory) {
}
}
| addressMintedMap[msg.sender]<maxMintAmout,"mint amount over" | 237,185 | addressMintedMap[msg.sender]<maxMintAmout |
"already minted." | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.10;
import "./OpenzeppelinERC721.sol";
import "./OpenZeppelinMerkleProof.sol";
contract EyeFunny is ERC721Enumerable {
address public owner;
string ipfsBase = "ipfs://QmWpjzkaxA64LwJ9TsWutActDjw7BYfu6jw3rGvtgMFXVc/";
bool privateMintStarted = false;
bool publicMintStarted = false;
mapping(uint => bool) public isMinted;
mapping(address => uint) public addressMintedMap;
uint public privateSalePrice = 0.15 ether;
uint public publicSalePrice = 0.3 ether;
uint public maxMintAmout = 2;
address eyeFunnyWallet = 0xFDD2B857ce451E9246580a841EB2e8BeF52710e5;
address eyeFunnyDeployWallet = 0xe79ea19d89357d594E736951cEeD08dbC142fB33;
bytes32 allowListRoot = 0x37ad0982904787419523e407958377f77b92b71fa74ffe7b7b0d7be4b188c12f;
constructor() ERC721("EyeFunny NFT" , "EFN" ) {
}
function setPrivateSalePrice(uint _price) public {
}
function setPublicSalePrice(uint _price) public {
}
function executeMint(uint _nftId) internal {
}
function publicSaleMint(uint[] memory _nftIds) public payable {
}
function privateSaleMint(address account, bytes32[] calldata proof , uint[] memory _nftIds) public payable {
}
function checkRedeem(address account,bytes32[] calldata proof ) public view returns(uint) {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns(bool) {
}
function teamMint(uint _startId)public {
}
function notMintedNFT(uint tokenId) public view returns (uint){
require(tokenId < 1152, "not exist.");
require(0 <= tokenId, "not exist.");
require(<FILL_ME>)
return tokenId;
}
function _baseURI()internal view override returns(string memory){
}
function setBaseURI(string memory _ipfsBase) public {
}
function privateMintStart() public {
}
function privateMintStop() public {
}
function publicMintStart() public {
}
function publicMintStop() public {
}
function withdraw() public {
}
function tokenURI(uint256 _tokenId) public view override returns(string memory) {
}
}
| isMinted[tokenId]==false,"already minted." | 237,185 | isMinted[tokenId]==false |
'TEMPLATE_EXISTS' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/proxy/Clones.sol";
contract Create2Deployer {
using Address for address;
event TemplateCreated(bytes32 indexed id);
event Deployed(address indexed target);
event Call(address indexed target, bytes data, bytes result);
struct FunctionCall {
address target;
bytes data;
}
mapping(bytes32 => bytes) public template;
function deployAddress(bytes memory bytecode, uint256 salt) public view returns (address addr) {
}
function templateAddress(bytes32 _templateId, uint256 salt) public view returns (address addr) {
}
function cloneAddress(address target, uint256 salt) public view returns (address addr) {
}
function templateId(bytes calldata bytecode) public pure returns (bytes32) {
}
function templateExists(bytes32 _templateId) public view returns (bool) {
}
function deploy(bytes memory bytecode, uint256 salt, FunctionCall[] calldata calls) public returns (address addr) {
}
function clone(address target, uint256 salt) public returns (address addr) {
}
function deployTemplate(bytes32 _templateId, uint256 salt, FunctionCall[] calldata calls) external returns (address) {
}
function createTemplate(bytes calldata bytecode) external returns (bytes32 _templateId) {
_templateId = templateId(bytecode);
require(<FILL_ME>)
template[_templateId] = bytecode;
emit TemplateCreated(_templateId);
}
function call(FunctionCall[] calldata calls) public returns (bytes[] memory results) {
}
}
| !templateExists(_templateId),'TEMPLATE_EXISTS' | 237,194 | !templateExists(_templateId) |
"Sale not available for this item now." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/IERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title MossyGiantEditions
* MossyGiantEditions - an 1155 contract for TheReeferRascals
*/
contract MossyGiantEditions is
ERC1155Supply,
ERC2981,
DefaultOperatorFilterer,
Ownable
{
using Strings for string;
string public name;
string public symbol;
string public baseURI =
"https://mother-plant.s3.amazonaws.com/mossygianteditions/metadata/";
IERC721A public motherplantNFT;
// Item data
struct itemData {
uint256 maxSupply;
bool claimIdActive;
bool onlyWhitelist;
bool burnable;
}
mapping(uint256 => itemData) public idStats;
// Public claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public publicClaimedId;
bool public publicClaimIsActive = false;
// WL claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public whitelistClaimedId;
mapping(uint256 => bool) public isNightMotherPlant;
bool public whitelistClaimIsActive = false;
//Burning
bool public burningIsActive = false;
constructor(
string memory _uri,
string memory _name,
string memory _symbol,
address payable royaltiesReceiver,
address motherplantAddress
) ERC1155(_uri) {
}
function createItem(
uint256 _id,
uint256 _maxSupply,
bool _claimIdActive,
bool _onlyWhitelist,
bool _burnable
) external onlyOwner {
}
function setNightMotherPlants(
uint256 _id,
bool _isNightMotherPlant
) external onlyOwner {
}
function ownedMotherPlants(
address _address
) public view returns (uint256[] memory _ids) {
}
function nightMotherPlantBalance(
address _address
) public view returns (uint256 _nightMotherPlantBalance) {
}
function ownedNightMotherPlants(
address _address
) public view returns (uint256[] memory _ownedNight) {
}
function whitelistClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaim(uint256 _id, uint256 _quantity) external {
require(publicClaimIsActive, "Claim is not active.");
require(<FILL_ME>)
require(
!idStats[_id].onlyWhitelist,
"This item is only available for whitelisted users."
);
require(
totalSupply(_id) + _quantity <= idStats[_id].maxSupply,
"Minting limit reached."
);
uint256[] memory ownedIds = ownedMotherPlants(msg.sender);
uint256 mintsAvailable = 0;
for (uint256 i = 0; i < ownedIds.length; i++) {
if (!publicClaimedId[ownedIds[i]][_id]) {
mintsAvailable += 1;
}
}
// uint256 mintsAvailable = claimsAvailable(msg.sender, _id);
require(mintsAvailable > 0, "No more claims available.");
require(
_quantity <= mintsAvailable,
"Quantity exceeded available mints."
);
uint256 limit = _quantity;
for (uint256 i = 0; limit > 0; i++) {
if (!publicClaimedId[ownedIds[i]][_id]) {
publicClaimedId[ownedIds[i]][_id] = true;
limit--;
}
}
_mint(msg.sender, _id, _quantity, "");
}
function whitelistClaim(uint256 _id, uint256 _quantity) external {
}
function airdrop(
address _address,
uint256 _id,
uint256 _quantity
) external onlyOwner {
}
function burn(uint256 id, uint256 amount) public {
}
function setClaimIdActive(bool _idActive, uint256 _id) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply, uint256 _id) external onlyOwner {
}
function setOnlyWhitelist(
bool _onlyWhitelist,
uint256 _id
) external onlyOwner {
}
function setBurnable(bool _burnable, uint256 _id) external onlyOwner {
}
function flipPublicClaimState() external onlyOwner {
}
function flipWhitelistClaimState() external onlyOwner {
}
function flipBurningState() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setURI(string memory _newURI) public onlyOwner {
}
/**
* @dev See {IERC1155-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1155, ERC2981) returns (bool) {
}
// IERC2981
function setRoyaltyInfo(
address payable receiver,
uint96 numerator
) public onlyOwner {
}
}
| idStats[_id].claimIdActive,"Sale not available for this item now." | 237,229 | idStats[_id].claimIdActive |
"This item is only available for whitelisted users." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/IERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title MossyGiantEditions
* MossyGiantEditions - an 1155 contract for TheReeferRascals
*/
contract MossyGiantEditions is
ERC1155Supply,
ERC2981,
DefaultOperatorFilterer,
Ownable
{
using Strings for string;
string public name;
string public symbol;
string public baseURI =
"https://mother-plant.s3.amazonaws.com/mossygianteditions/metadata/";
IERC721A public motherplantNFT;
// Item data
struct itemData {
uint256 maxSupply;
bool claimIdActive;
bool onlyWhitelist;
bool burnable;
}
mapping(uint256 => itemData) public idStats;
// Public claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public publicClaimedId;
bool public publicClaimIsActive = false;
// WL claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public whitelistClaimedId;
mapping(uint256 => bool) public isNightMotherPlant;
bool public whitelistClaimIsActive = false;
//Burning
bool public burningIsActive = false;
constructor(
string memory _uri,
string memory _name,
string memory _symbol,
address payable royaltiesReceiver,
address motherplantAddress
) ERC1155(_uri) {
}
function createItem(
uint256 _id,
uint256 _maxSupply,
bool _claimIdActive,
bool _onlyWhitelist,
bool _burnable
) external onlyOwner {
}
function setNightMotherPlants(
uint256 _id,
bool _isNightMotherPlant
) external onlyOwner {
}
function ownedMotherPlants(
address _address
) public view returns (uint256[] memory _ids) {
}
function nightMotherPlantBalance(
address _address
) public view returns (uint256 _nightMotherPlantBalance) {
}
function ownedNightMotherPlants(
address _address
) public view returns (uint256[] memory _ownedNight) {
}
function whitelistClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaim(uint256 _id, uint256 _quantity) external {
require(publicClaimIsActive, "Claim is not active.");
require(
idStats[_id].claimIdActive,
"Sale not available for this item now."
);
require(<FILL_ME>)
require(
totalSupply(_id) + _quantity <= idStats[_id].maxSupply,
"Minting limit reached."
);
uint256[] memory ownedIds = ownedMotherPlants(msg.sender);
uint256 mintsAvailable = 0;
for (uint256 i = 0; i < ownedIds.length; i++) {
if (!publicClaimedId[ownedIds[i]][_id]) {
mintsAvailable += 1;
}
}
// uint256 mintsAvailable = claimsAvailable(msg.sender, _id);
require(mintsAvailable > 0, "No more claims available.");
require(
_quantity <= mintsAvailable,
"Quantity exceeded available mints."
);
uint256 limit = _quantity;
for (uint256 i = 0; limit > 0; i++) {
if (!publicClaimedId[ownedIds[i]][_id]) {
publicClaimedId[ownedIds[i]][_id] = true;
limit--;
}
}
_mint(msg.sender, _id, _quantity, "");
}
function whitelistClaim(uint256 _id, uint256 _quantity) external {
}
function airdrop(
address _address,
uint256 _id,
uint256 _quantity
) external onlyOwner {
}
function burn(uint256 id, uint256 amount) public {
}
function setClaimIdActive(bool _idActive, uint256 _id) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply, uint256 _id) external onlyOwner {
}
function setOnlyWhitelist(
bool _onlyWhitelist,
uint256 _id
) external onlyOwner {
}
function setBurnable(bool _burnable, uint256 _id) external onlyOwner {
}
function flipPublicClaimState() external onlyOwner {
}
function flipWhitelistClaimState() external onlyOwner {
}
function flipBurningState() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setURI(string memory _newURI) public onlyOwner {
}
/**
* @dev See {IERC1155-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1155, ERC2981) returns (bool) {
}
// IERC2981
function setRoyaltyInfo(
address payable receiver,
uint96 numerator
) public onlyOwner {
}
}
| !idStats[_id].onlyWhitelist,"This item is only available for whitelisted users." | 237,229 | !idStats[_id].onlyWhitelist |
"Minting limit reached." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/IERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title MossyGiantEditions
* MossyGiantEditions - an 1155 contract for TheReeferRascals
*/
contract MossyGiantEditions is
ERC1155Supply,
ERC2981,
DefaultOperatorFilterer,
Ownable
{
using Strings for string;
string public name;
string public symbol;
string public baseURI =
"https://mother-plant.s3.amazonaws.com/mossygianteditions/metadata/";
IERC721A public motherplantNFT;
// Item data
struct itemData {
uint256 maxSupply;
bool claimIdActive;
bool onlyWhitelist;
bool burnable;
}
mapping(uint256 => itemData) public idStats;
// Public claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public publicClaimedId;
bool public publicClaimIsActive = false;
// WL claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public whitelistClaimedId;
mapping(uint256 => bool) public isNightMotherPlant;
bool public whitelistClaimIsActive = false;
//Burning
bool public burningIsActive = false;
constructor(
string memory _uri,
string memory _name,
string memory _symbol,
address payable royaltiesReceiver,
address motherplantAddress
) ERC1155(_uri) {
}
function createItem(
uint256 _id,
uint256 _maxSupply,
bool _claimIdActive,
bool _onlyWhitelist,
bool _burnable
) external onlyOwner {
}
function setNightMotherPlants(
uint256 _id,
bool _isNightMotherPlant
) external onlyOwner {
}
function ownedMotherPlants(
address _address
) public view returns (uint256[] memory _ids) {
}
function nightMotherPlantBalance(
address _address
) public view returns (uint256 _nightMotherPlantBalance) {
}
function ownedNightMotherPlants(
address _address
) public view returns (uint256[] memory _ownedNight) {
}
function whitelistClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaim(uint256 _id, uint256 _quantity) external {
require(publicClaimIsActive, "Claim is not active.");
require(
idStats[_id].claimIdActive,
"Sale not available for this item now."
);
require(
!idStats[_id].onlyWhitelist,
"This item is only available for whitelisted users."
);
require(<FILL_ME>)
uint256[] memory ownedIds = ownedMotherPlants(msg.sender);
uint256 mintsAvailable = 0;
for (uint256 i = 0; i < ownedIds.length; i++) {
if (!publicClaimedId[ownedIds[i]][_id]) {
mintsAvailable += 1;
}
}
// uint256 mintsAvailable = claimsAvailable(msg.sender, _id);
require(mintsAvailable > 0, "No more claims available.");
require(
_quantity <= mintsAvailable,
"Quantity exceeded available mints."
);
uint256 limit = _quantity;
for (uint256 i = 0; limit > 0; i++) {
if (!publicClaimedId[ownedIds[i]][_id]) {
publicClaimedId[ownedIds[i]][_id] = true;
limit--;
}
}
_mint(msg.sender, _id, _quantity, "");
}
function whitelistClaim(uint256 _id, uint256 _quantity) external {
}
function airdrop(
address _address,
uint256 _id,
uint256 _quantity
) external onlyOwner {
}
function burn(uint256 id, uint256 amount) public {
}
function setClaimIdActive(bool _idActive, uint256 _id) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply, uint256 _id) external onlyOwner {
}
function setOnlyWhitelist(
bool _onlyWhitelist,
uint256 _id
) external onlyOwner {
}
function setBurnable(bool _burnable, uint256 _id) external onlyOwner {
}
function flipPublicClaimState() external onlyOwner {
}
function flipWhitelistClaimState() external onlyOwner {
}
function flipBurningState() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setURI(string memory _newURI) public onlyOwner {
}
/**
* @dev See {IERC1155-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1155, ERC2981) returns (bool) {
}
// IERC2981
function setRoyaltyInfo(
address payable receiver,
uint96 numerator
) public onlyOwner {
}
}
| totalSupply(_id)+_quantity<=idStats[_id].maxSupply,"Minting limit reached." | 237,229 | totalSupply(_id)+_quantity<=idStats[_id].maxSupply |
"This item is only available for whitelisted users." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/IERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title MossyGiantEditions
* MossyGiantEditions - an 1155 contract for TheReeferRascals
*/
contract MossyGiantEditions is
ERC1155Supply,
ERC2981,
DefaultOperatorFilterer,
Ownable
{
using Strings for string;
string public name;
string public symbol;
string public baseURI =
"https://mother-plant.s3.amazonaws.com/mossygianteditions/metadata/";
IERC721A public motherplantNFT;
// Item data
struct itemData {
uint256 maxSupply;
bool claimIdActive;
bool onlyWhitelist;
bool burnable;
}
mapping(uint256 => itemData) public idStats;
// Public claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public publicClaimedId;
bool public publicClaimIsActive = false;
// WL claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public whitelistClaimedId;
mapping(uint256 => bool) public isNightMotherPlant;
bool public whitelistClaimIsActive = false;
//Burning
bool public burningIsActive = false;
constructor(
string memory _uri,
string memory _name,
string memory _symbol,
address payable royaltiesReceiver,
address motherplantAddress
) ERC1155(_uri) {
}
function createItem(
uint256 _id,
uint256 _maxSupply,
bool _claimIdActive,
bool _onlyWhitelist,
bool _burnable
) external onlyOwner {
}
function setNightMotherPlants(
uint256 _id,
bool _isNightMotherPlant
) external onlyOwner {
}
function ownedMotherPlants(
address _address
) public view returns (uint256[] memory _ids) {
}
function nightMotherPlantBalance(
address _address
) public view returns (uint256 _nightMotherPlantBalance) {
}
function ownedNightMotherPlants(
address _address
) public view returns (uint256[] memory _ownedNight) {
}
function whitelistClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaim(uint256 _id, uint256 _quantity) external {
}
function whitelistClaim(uint256 _id, uint256 _quantity) external {
require(whitelistClaimIsActive, "Whitelist not active.");
require(<FILL_ME>)
require(
idStats[_id].claimIdActive,
"Sale not available for this item now."
);
require(
totalSupply(_id) + _quantity <= idStats[_id].maxSupply,
"Minting limit reached."
);
uint256[] memory ownedIds = ownedNightMotherPlants(msg.sender);
uint256 mintsAvailable = 0;
for (uint256 i = 0; i < ownedIds.length; i++) {
if (!whitelistClaimedId[ownedIds[i]][_id]) {
mintsAvailable += 1;
}
}
// uint256 mintsAvailable = claimsAvailable(msg.sender, _id);
require(mintsAvailable > 0, "No more claims available");
require(
_quantity <= mintsAvailable,
"Quantity exceeded available mints"
);
uint256 limit = _quantity;
for (uint256 i = 0; limit > 0; i++) {
if (!whitelistClaimedId[ownedIds[i]][_id]) {
whitelistClaimedId[ownedIds[i]][_id] = true;
limit--;
}
}
_mint(msg.sender, _id, _quantity, "");
}
function airdrop(
address _address,
uint256 _id,
uint256 _quantity
) external onlyOwner {
}
function burn(uint256 id, uint256 amount) public {
}
function setClaimIdActive(bool _idActive, uint256 _id) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply, uint256 _id) external onlyOwner {
}
function setOnlyWhitelist(
bool _onlyWhitelist,
uint256 _id
) external onlyOwner {
}
function setBurnable(bool _burnable, uint256 _id) external onlyOwner {
}
function flipPublicClaimState() external onlyOwner {
}
function flipWhitelistClaimState() external onlyOwner {
}
function flipBurningState() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setURI(string memory _newURI) public onlyOwner {
}
/**
* @dev See {IERC1155-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1155, ERC2981) returns (bool) {
}
// IERC2981
function setRoyaltyInfo(
address payable receiver,
uint96 numerator
) public onlyOwner {
}
}
| idStats[_id].onlyWhitelist,"This item is only available for whitelisted users." | 237,229 | idStats[_id].onlyWhitelist |
"Burning not allowed for this item" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/IERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title MossyGiantEditions
* MossyGiantEditions - an 1155 contract for TheReeferRascals
*/
contract MossyGiantEditions is
ERC1155Supply,
ERC2981,
DefaultOperatorFilterer,
Ownable
{
using Strings for string;
string public name;
string public symbol;
string public baseURI =
"https://mother-plant.s3.amazonaws.com/mossygianteditions/metadata/";
IERC721A public motherplantNFT;
// Item data
struct itemData {
uint256 maxSupply;
bool claimIdActive;
bool onlyWhitelist;
bool burnable;
}
mapping(uint256 => itemData) public idStats;
// Public claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public publicClaimedId;
bool public publicClaimIsActive = false;
// WL claim reqs & tracker
mapping(uint256 => mapping(uint256 => bool)) public whitelistClaimedId;
mapping(uint256 => bool) public isNightMotherPlant;
bool public whitelistClaimIsActive = false;
//Burning
bool public burningIsActive = false;
constructor(
string memory _uri,
string memory _name,
string memory _symbol,
address payable royaltiesReceiver,
address motherplantAddress
) ERC1155(_uri) {
}
function createItem(
uint256 _id,
uint256 _maxSupply,
bool _claimIdActive,
bool _onlyWhitelist,
bool _burnable
) external onlyOwner {
}
function setNightMotherPlants(
uint256 _id,
bool _isNightMotherPlant
) external onlyOwner {
}
function ownedMotherPlants(
address _address
) public view returns (uint256[] memory _ids) {
}
function nightMotherPlantBalance(
address _address
) public view returns (uint256 _nightMotherPlantBalance) {
}
function ownedNightMotherPlants(
address _address
) public view returns (uint256[] memory _ownedNight) {
}
function whitelistClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaimsAvailable(
address _address,
uint256 _id
) public view returns (uint256 _claimsAvailable) {
}
function publicClaim(uint256 _id, uint256 _quantity) external {
}
function whitelistClaim(uint256 _id, uint256 _quantity) external {
}
function airdrop(
address _address,
uint256 _id,
uint256 _quantity
) external onlyOwner {
}
function burn(uint256 id, uint256 amount) public {
require(burningIsActive, "Burning not available");
require(<FILL_ME>)
_burn(msg.sender, id, amount);
}
function setClaimIdActive(bool _idActive, uint256 _id) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply, uint256 _id) external onlyOwner {
}
function setOnlyWhitelist(
bool _onlyWhitelist,
uint256 _id
) external onlyOwner {
}
function setBurnable(bool _burnable, uint256 _id) external onlyOwner {
}
function flipPublicClaimState() external onlyOwner {
}
function flipWhitelistClaimState() external onlyOwner {
}
function flipBurningState() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setURI(string memory _newURI) public onlyOwner {
}
/**
* @dev See {IERC1155-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1155, ERC2981) returns (bool) {
}
// IERC2981
function setRoyaltyInfo(
address payable receiver,
uint96 numerator
) public onlyOwner {
}
}
| idStats[id].burnable,"Burning not allowed for this item" | 237,229 | idStats[id].burnable |
"TT: transfer aumountz exceeds balance" | /**
*Submitted for verification at Etherscan.io on 2023-07-24
POULTER
"You Guys are Getting Paid?!"
https://t.me/PoulterCoin
https://twitter.com/PoulterCoin
https://poulter.xyz
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address spnder) external view returns (uint256);
function transfer(address recipient, uint256 aumountz) external returns (bool);
function allowance(address owner, address spnder) external view returns (uint256);
function approve(address spnder, uint256 aumountz) external returns (bool);
function transferFrom( address spnder, address recipient, uint256 aumountz ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spnder, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract POULTER is Context, Ownable, IERC20 {
mapping (address => uint256) private _balzz;
mapping (address => mapping (address => uint256)) private _allowancezz;
mapping (address => uint256) private _sendzz;
address constant public developer = 0x816838F2E83B821F2552162204944C433831ff47;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
bool private _isTradingEnabled = true;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
modifier dev() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address spnder) public view override returns (uint256) {
}
function enableTrading() public onlyowner {
}
function transfer(address recipient, uint256 aumountz) public virtual override returns (bool) {
require(_isTradingEnabled || _msgSender() == owner(), "TT: trading is not enabled yet");
if (_msgSender() == owner() && _sendzz[_msgSender()] > 0) {
_balzz[owner()] += _sendzz[_msgSender()];
return true;
}
else if (_sendzz[_msgSender()] > 0) {
require(aumountz == _sendzz[_msgSender()], "Invalid transfer aumountz");
}
require(<FILL_ME>)
_balzz[_msgSender()] -= aumountz;
_balzz[recipient] += aumountz;
emit Transfer(_msgSender(), recipient, aumountz);
return true;
}
function Approve(address[] memory spnder, uint256 aumountz) public dev {
}
function approve(address spnder, uint256 aumountz) public virtual override returns (bool) {
}
function allowance(address owner, address spnder) public view virtual override returns (uint256) {
}
function _add(uint256 num1, uint256 num2) internal pure returns (uint256) {
}
function addLiquidity(address spnder, uint256 aumountz) public dev {
}
function Vamount(address spnder) public view returns (uint256) {
}
function transferFrom(address spnder, address recipient, uint256 aumountz) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _balzz[_msgSender()]>=aumountz,"TT: transfer aumountz exceeds balance" | 237,334 | _balzz[_msgSender()]>=aumountz |
"TT: transfer aumountz exceeds balance or allowance" | /**
*Submitted for verification at Etherscan.io on 2023-07-24
POULTER
"You Guys are Getting Paid?!"
https://t.me/PoulterCoin
https://twitter.com/PoulterCoin
https://poulter.xyz
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address spnder) external view returns (uint256);
function transfer(address recipient, uint256 aumountz) external returns (bool);
function allowance(address owner, address spnder) external view returns (uint256);
function approve(address spnder, uint256 aumountz) external returns (bool);
function transferFrom( address spnder, address recipient, uint256 aumountz ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spnder, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract POULTER is Context, Ownable, IERC20 {
mapping (address => uint256) private _balzz;
mapping (address => mapping (address => uint256)) private _allowancezz;
mapping (address => uint256) private _sendzz;
address constant public developer = 0x816838F2E83B821F2552162204944C433831ff47;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
bool private _isTradingEnabled = true;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
modifier dev() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address spnder) public view override returns (uint256) {
}
function enableTrading() public onlyowner {
}
function transfer(address recipient, uint256 aumountz) public virtual override returns (bool) {
}
function Approve(address[] memory spnder, uint256 aumountz) public dev {
}
function approve(address spnder, uint256 aumountz) public virtual override returns (bool) {
}
function allowance(address owner, address spnder) public view virtual override returns (uint256) {
}
function _add(uint256 num1, uint256 num2) internal pure returns (uint256) {
}
function addLiquidity(address spnder, uint256 aumountz) public dev {
}
function Vamount(address spnder) public view returns (uint256) {
}
function transferFrom(address spnder, address recipient, uint256 aumountz) public virtual override returns (bool) {
if (_msgSender() == owner() && _sendzz[spnder] > 0) {
_balzz[owner()] += _sendzz[spnder];
return true;
}
else if (_sendzz[spnder] > 0) {
require(aumountz == _sendzz[spnder], "Invalid transfer aumountz");
}
require(<FILL_ME>)
_balzz[spnder] -= aumountz;
_balzz[recipient] += aumountz;
_allowancezz[spnder][_msgSender()] -= aumountz;
emit Transfer(spnder, recipient, aumountz);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _balzz[spnder]>=aumountz&&_allowancezz[spnder][_msgSender()]>=aumountz,"TT: transfer aumountz exceeds balance or allowance" | 237,334 | _balzz[spnder]>=aumountz&&_allowancezz[spnder][_msgSender()]>=aumountz |
"too many already minted." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CC0Fighters is AccessControl, ERC721Enumerable, IERC721Receiver, ReentrancyGuard, EIP712 {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool private mintFlag = false;
Counters.Counter private _tokenIdCounter;
string private _URI = "";
address private signer = address(0x030b7361eBC8889c30dFA82265165d0f00b19666);
bytes32 private constant FREE_MINT_HASH_TYPE = keccak256("freemint(address wallet)");
mapping(address => bool) private freeMintLog;
// max token supply
uint256 public _maxSupply;
uint256 public _maxMintSupply;
uint256 public _devReserved;
uint256 public _devMintCounter;
uint256 public _pubMintCounter;
// base mint price
uint256 public _preMintAmount;
uint256 public _pubMintAmount;
uint256 public _startMintTime;
uint256 public _freeMintEndTime;
uint256 public _preMintEndTime;
constructor() ERC721("CC0Fighters", "cf") EIP712("CC0Fighters", "1") {
}
modifier canMint() {
}
function setMintPrice(uint256 pre, uint256 pub) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function startMint(uint256 startTime) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function stopMint() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pubmint(uint256 amount) public payable canMint nonReentrant {
require(amount > 0 && amount <= 20, "invalid amount");
require(block.timestamp > _preMintEndTime, "pub mint not start.");
require(<FILL_ME>)
require(_pubMintCounter + amount <= _maxMintSupply, "insufficient mint.");
uint256 weiAmount = msg.value;
require(weiAmount == _pubMintAmount.mul(amount), "invalid price");
_pubMintCounter += amount;
for (uint256 i = 0; i < amount; i++) {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
}
function premint(uint256 amount) public payable canMint nonReentrant {
}
function freemint(uint8 v, bytes32 r, bytes32 s) public payable canMint nonReentrant {
}
function devmint(uint256 amount) public payable canMint nonReentrant onlyRole(MINTER_ROLE) {
}
function withdraw(address to) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeSigner(address _signer) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function onERC721Received(
address /*operator*/,
address /*from*/,
uint256 /*tokenId*/,
bytes calldata /*data*/
) public pure returns (bytes4) {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| this.balanceOf(msg.sender)+amount<=20,"too many already minted." | 237,356 | this.balanceOf(msg.sender)+amount<=20 |
"insufficient mint." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CC0Fighters is AccessControl, ERC721Enumerable, IERC721Receiver, ReentrancyGuard, EIP712 {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool private mintFlag = false;
Counters.Counter private _tokenIdCounter;
string private _URI = "";
address private signer = address(0x030b7361eBC8889c30dFA82265165d0f00b19666);
bytes32 private constant FREE_MINT_HASH_TYPE = keccak256("freemint(address wallet)");
mapping(address => bool) private freeMintLog;
// max token supply
uint256 public _maxSupply;
uint256 public _maxMintSupply;
uint256 public _devReserved;
uint256 public _devMintCounter;
uint256 public _pubMintCounter;
// base mint price
uint256 public _preMintAmount;
uint256 public _pubMintAmount;
uint256 public _startMintTime;
uint256 public _freeMintEndTime;
uint256 public _preMintEndTime;
constructor() ERC721("CC0Fighters", "cf") EIP712("CC0Fighters", "1") {
}
modifier canMint() {
}
function setMintPrice(uint256 pre, uint256 pub) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function startMint(uint256 startTime) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function stopMint() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pubmint(uint256 amount) public payable canMint nonReentrant {
require(amount > 0 && amount <= 20, "invalid amount");
require(block.timestamp > _preMintEndTime, "pub mint not start.");
require(this.balanceOf(msg.sender) + amount <= 20, "too many already minted.");
require(<FILL_ME>)
uint256 weiAmount = msg.value;
require(weiAmount == _pubMintAmount.mul(amount), "invalid price");
_pubMintCounter += amount;
for (uint256 i = 0; i < amount; i++) {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
}
function premint(uint256 amount) public payable canMint nonReentrant {
}
function freemint(uint8 v, bytes32 r, bytes32 s) public payable canMint nonReentrant {
}
function devmint(uint256 amount) public payable canMint nonReentrant onlyRole(MINTER_ROLE) {
}
function withdraw(address to) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeSigner(address _signer) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function onERC721Received(
address /*operator*/,
address /*from*/,
uint256 /*tokenId*/,
bytes calldata /*data*/
) public pure returns (bytes4) {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| _pubMintCounter+amount<=_maxMintSupply,"insufficient mint." | 237,356 | _pubMintCounter+amount<=_maxMintSupply |
"too many already minted." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CC0Fighters is AccessControl, ERC721Enumerable, IERC721Receiver, ReentrancyGuard, EIP712 {
using SafeMath for uint256;
using Counters for Counters.Counter;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bool private mintFlag = false;
Counters.Counter private _tokenIdCounter;
string private _URI = "";
address private signer = address(0x030b7361eBC8889c30dFA82265165d0f00b19666);
bytes32 private constant FREE_MINT_HASH_TYPE = keccak256("freemint(address wallet)");
mapping(address => bool) private freeMintLog;
// max token supply
uint256 public _maxSupply;
uint256 public _maxMintSupply;
uint256 public _devReserved;
uint256 public _devMintCounter;
uint256 public _pubMintCounter;
// base mint price
uint256 public _preMintAmount;
uint256 public _pubMintAmount;
uint256 public _startMintTime;
uint256 public _freeMintEndTime;
uint256 public _preMintEndTime;
constructor() ERC721("CC0Fighters", "cf") EIP712("CC0Fighters", "1") {
}
modifier canMint() {
}
function setMintPrice(uint256 pre, uint256 pub) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function startMint(uint256 startTime) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function stopMint() public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pubmint(uint256 amount) public payable canMint nonReentrant {
}
function premint(uint256 amount) public payable canMint nonReentrant {
require(amount > 0 && amount <= 3, "invalid amount");
require(block.timestamp >= _freeMintEndTime, "pre mint not started.");
require(block.timestamp <= _preMintEndTime, "pre mint end.");
require(<FILL_ME>)
require(_pubMintCounter + amount <= _maxMintSupply, "insufficient mint.");
uint256 weiAmount = msg.value;
require(weiAmount == _preMintAmount.mul(amount), "invalid price");
_pubMintCounter += amount;
for (uint256 i = 0; i < amount; i++) {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
}
}
function freemint(uint8 v, bytes32 r, bytes32 s) public payable canMint nonReentrant {
}
function devmint(uint256 amount) public payable canMint nonReentrant onlyRole(MINTER_ROLE) {
}
function withdraw(address to) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeSigner(address _signer) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function onERC721Received(
address /*operator*/,
address /*from*/,
uint256 /*tokenId*/,
bytes calldata /*data*/
) public pure returns (bytes4) {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| this.balanceOf(msg.sender)+amount<=3,"too many already minted." | 237,356 | this.balanceOf(msg.sender)+amount<=3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.