comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"NOT_GOLD_LISTED" | //Developed by Orcania (https://orcania.io)
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
interface IERC20{
function transfer(address recipient, uint256 amount) external;
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address payable to, uint256 value) external Owner {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) external override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
function burn(uint256 tokenId) external {
}
//Internal Functions======================================================================================================================================================
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract chaoticDJs is OERC721 {
using Strings for uint256;
bytes32 private _glRoot;
uint256 private _glPrice;
uint256 private _glUserMintLimit;
uint256 private _glMintLimit;
uint256 private _glActive;
mapping(address => uint256) _glUserMints; //Amount of mints performed by this user
uint256 private _glMints; //Amount of mints performed in this mint
bytes32 private _wlRoot;
uint256 private _wlPrice;
uint256 private _wlUserMintLimit;
uint256 private _wlMintLimit;
uint256 private _wlActive;
mapping(address => uint256) _wlUserMints; //Amount of mints performed by this user
uint256 private _wlMints; //Amount of mints performed in this mint
uint256 private _pmPrice;
uint256 private _pmUserMintLimit;
uint256 private _pmActive;
mapping(address => uint256) _pmUserMints; //Amount of mints performed by this user
uint256 _maxSupply;
uint256 private _reveal;
constructor() {
}
//Read Functions===========================================================================================================================================================
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function glData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function wlData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function pmData(address user) external view returns(uint256 userMints, uint256 price, uint256 userMintLimit, bool active) {
}
function maxSupply() external view returns(uint256) { }
//Moderator Functions======================================================================================================================================================
function setGlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setWlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setPmData(uint256 price, uint256 userMintLimit, uint256 active) external Manager {
}
function setMaxSupply(uint256 maxSupply) external Manager {
}
function setReveal(uint256 reveal) external Manager {
}
//User Functions======================================================================================================================================================
function glMint(bytes32[] calldata _merkleProof) external payable {
require(_glMints < _glMintLimit, "CDS: WL has sold out");
require(_glActive == 1, "CDS: WL minting is closed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
uint256 price = _glPrice;
require(msg.value % price == 0, "CDS: Wrong Value");
uint256 amount = msg.value / price;
require((_glMints += amount) <= _glMintLimit, "CDS: Mint Limit Exceeded");
require((_glUserMints[msg.sender] += amount) <= _glUserMintLimit, "CDS: User Mint Limit Exceeded");
_mint(msg.sender, amount);
require(_totalSupply <= _maxSupply, "CDS: Supply Exceeded");
}
function wlMint(bytes32[] calldata _merkleProof) external payable {
}
function pmMint() external payable {
}
}
| MerkleProof.verify(_merkleProof,_glRoot,leaf),"NOT_GOLD_LISTED" | 180,011 | MerkleProof.verify(_merkleProof,_glRoot,leaf) |
"CDS: Mint Limit Exceeded" | //Developed by Orcania (https://orcania.io)
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
interface IERC20{
function transfer(address recipient, uint256 amount) external;
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address payable to, uint256 value) external Owner {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) external override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
function burn(uint256 tokenId) external {
}
//Internal Functions======================================================================================================================================================
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract chaoticDJs is OERC721 {
using Strings for uint256;
bytes32 private _glRoot;
uint256 private _glPrice;
uint256 private _glUserMintLimit;
uint256 private _glMintLimit;
uint256 private _glActive;
mapping(address => uint256) _glUserMints; //Amount of mints performed by this user
uint256 private _glMints; //Amount of mints performed in this mint
bytes32 private _wlRoot;
uint256 private _wlPrice;
uint256 private _wlUserMintLimit;
uint256 private _wlMintLimit;
uint256 private _wlActive;
mapping(address => uint256) _wlUserMints; //Amount of mints performed by this user
uint256 private _wlMints; //Amount of mints performed in this mint
uint256 private _pmPrice;
uint256 private _pmUserMintLimit;
uint256 private _pmActive;
mapping(address => uint256) _pmUserMints; //Amount of mints performed by this user
uint256 _maxSupply;
uint256 private _reveal;
constructor() {
}
//Read Functions===========================================================================================================================================================
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function glData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function wlData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function pmData(address user) external view returns(uint256 userMints, uint256 price, uint256 userMintLimit, bool active) {
}
function maxSupply() external view returns(uint256) { }
//Moderator Functions======================================================================================================================================================
function setGlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setWlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setPmData(uint256 price, uint256 userMintLimit, uint256 active) external Manager {
}
function setMaxSupply(uint256 maxSupply) external Manager {
}
function setReveal(uint256 reveal) external Manager {
}
//User Functions======================================================================================================================================================
function glMint(bytes32[] calldata _merkleProof) external payable {
require(_glMints < _glMintLimit, "CDS: WL has sold out");
require(_glActive == 1, "CDS: WL minting is closed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, _glRoot, leaf), "NOT_GOLD_LISTED");
uint256 price = _glPrice;
require(msg.value % price == 0, "CDS: Wrong Value");
uint256 amount = msg.value / price;
require(<FILL_ME>)
require((_glUserMints[msg.sender] += amount) <= _glUserMintLimit, "CDS: User Mint Limit Exceeded");
_mint(msg.sender, amount);
require(_totalSupply <= _maxSupply, "CDS: Supply Exceeded");
}
function wlMint(bytes32[] calldata _merkleProof) external payable {
}
function pmMint() external payable {
}
}
| (_glMints+=amount)<=_glMintLimit,"CDS: Mint Limit Exceeded" | 180,011 | (_glMints+=amount)<=_glMintLimit |
"CDS: User Mint Limit Exceeded" | //Developed by Orcania (https://orcania.io)
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
interface IERC20{
function transfer(address recipient, uint256 amount) external;
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address payable to, uint256 value) external Owner {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) external override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
function burn(uint256 tokenId) external {
}
//Internal Functions======================================================================================================================================================
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract chaoticDJs is OERC721 {
using Strings for uint256;
bytes32 private _glRoot;
uint256 private _glPrice;
uint256 private _glUserMintLimit;
uint256 private _glMintLimit;
uint256 private _glActive;
mapping(address => uint256) _glUserMints; //Amount of mints performed by this user
uint256 private _glMints; //Amount of mints performed in this mint
bytes32 private _wlRoot;
uint256 private _wlPrice;
uint256 private _wlUserMintLimit;
uint256 private _wlMintLimit;
uint256 private _wlActive;
mapping(address => uint256) _wlUserMints; //Amount of mints performed by this user
uint256 private _wlMints; //Amount of mints performed in this mint
uint256 private _pmPrice;
uint256 private _pmUserMintLimit;
uint256 private _pmActive;
mapping(address => uint256) _pmUserMints; //Amount of mints performed by this user
uint256 _maxSupply;
uint256 private _reveal;
constructor() {
}
//Read Functions===========================================================================================================================================================
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function glData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function wlData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function pmData(address user) external view returns(uint256 userMints, uint256 price, uint256 userMintLimit, bool active) {
}
function maxSupply() external view returns(uint256) { }
//Moderator Functions======================================================================================================================================================
function setGlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setWlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setPmData(uint256 price, uint256 userMintLimit, uint256 active) external Manager {
}
function setMaxSupply(uint256 maxSupply) external Manager {
}
function setReveal(uint256 reveal) external Manager {
}
//User Functions======================================================================================================================================================
function glMint(bytes32[] calldata _merkleProof) external payable {
require(_glMints < _glMintLimit, "CDS: WL has sold out");
require(_glActive == 1, "CDS: WL minting is closed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, _glRoot, leaf), "NOT_GOLD_LISTED");
uint256 price = _glPrice;
require(msg.value % price == 0, "CDS: Wrong Value");
uint256 amount = msg.value / price;
require((_glMints += amount) <= _glMintLimit, "CDS: Mint Limit Exceeded");
require(<FILL_ME>)
_mint(msg.sender, amount);
require(_totalSupply <= _maxSupply, "CDS: Supply Exceeded");
}
function wlMint(bytes32[] calldata _merkleProof) external payable {
}
function pmMint() external payable {
}
}
| (_glUserMints[msg.sender]+=amount)<=_glUserMintLimit,"CDS: User Mint Limit Exceeded" | 180,011 | (_glUserMints[msg.sender]+=amount)<=_glUserMintLimit |
"NOT_GOLD_LISTED" | //Developed by Orcania (https://orcania.io)
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
interface IERC20{
function transfer(address recipient, uint256 amount) external;
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address payable to, uint256 value) external Owner {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) external override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
function burn(uint256 tokenId) external {
}
//Internal Functions======================================================================================================================================================
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract chaoticDJs is OERC721 {
using Strings for uint256;
bytes32 private _glRoot;
uint256 private _glPrice;
uint256 private _glUserMintLimit;
uint256 private _glMintLimit;
uint256 private _glActive;
mapping(address => uint256) _glUserMints; //Amount of mints performed by this user
uint256 private _glMints; //Amount of mints performed in this mint
bytes32 private _wlRoot;
uint256 private _wlPrice;
uint256 private _wlUserMintLimit;
uint256 private _wlMintLimit;
uint256 private _wlActive;
mapping(address => uint256) _wlUserMints; //Amount of mints performed by this user
uint256 private _wlMints; //Amount of mints performed in this mint
uint256 private _pmPrice;
uint256 private _pmUserMintLimit;
uint256 private _pmActive;
mapping(address => uint256) _pmUserMints; //Amount of mints performed by this user
uint256 _maxSupply;
uint256 private _reveal;
constructor() {
}
//Read Functions===========================================================================================================================================================
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function glData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function wlData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function pmData(address user) external view returns(uint256 userMints, uint256 price, uint256 userMintLimit, bool active) {
}
function maxSupply() external view returns(uint256) { }
//Moderator Functions======================================================================================================================================================
function setGlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setWlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setPmData(uint256 price, uint256 userMintLimit, uint256 active) external Manager {
}
function setMaxSupply(uint256 maxSupply) external Manager {
}
function setReveal(uint256 reveal) external Manager {
}
//User Functions======================================================================================================================================================
function glMint(bytes32[] calldata _merkleProof) external payable {
}
function wlMint(bytes32[] calldata _merkleProof) external payable {
require(_wlMints < _wlMintLimit, "CDS: WL has sold out");
require(_wlActive == 1, "CDS: WL minting is closed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
uint256 price = _wlPrice;
require(msg.value % price == 0, "CDS: Wrong Value");
uint256 amount = msg.value / price;
require((_wlMints += amount) <= _wlMintLimit, "CDS: Mint Limit Exceeded");
require((_wlUserMints[msg.sender] += amount) <= _wlUserMintLimit, "CDS: User Mint Limit Exceeded");
_mint(msg.sender, amount);
require(_totalSupply <= _maxSupply, "CDS: Supply Exceeded");
}
function pmMint() external payable {
}
}
| MerkleProof.verify(_merkleProof,_wlRoot,leaf),"NOT_GOLD_LISTED" | 180,011 | MerkleProof.verify(_merkleProof,_wlRoot,leaf) |
"CDS: Mint Limit Exceeded" | //Developed by Orcania (https://orcania.io)
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
interface IERC20{
function transfer(address recipient, uint256 amount) external;
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address payable to, uint256 value) external Owner {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) external override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
function burn(uint256 tokenId) external {
}
//Internal Functions======================================================================================================================================================
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract chaoticDJs is OERC721 {
using Strings for uint256;
bytes32 private _glRoot;
uint256 private _glPrice;
uint256 private _glUserMintLimit;
uint256 private _glMintLimit;
uint256 private _glActive;
mapping(address => uint256) _glUserMints; //Amount of mints performed by this user
uint256 private _glMints; //Amount of mints performed in this mint
bytes32 private _wlRoot;
uint256 private _wlPrice;
uint256 private _wlUserMintLimit;
uint256 private _wlMintLimit;
uint256 private _wlActive;
mapping(address => uint256) _wlUserMints; //Amount of mints performed by this user
uint256 private _wlMints; //Amount of mints performed in this mint
uint256 private _pmPrice;
uint256 private _pmUserMintLimit;
uint256 private _pmActive;
mapping(address => uint256) _pmUserMints; //Amount of mints performed by this user
uint256 _maxSupply;
uint256 private _reveal;
constructor() {
}
//Read Functions===========================================================================================================================================================
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function glData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function wlData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function pmData(address user) external view returns(uint256 userMints, uint256 price, uint256 userMintLimit, bool active) {
}
function maxSupply() external view returns(uint256) { }
//Moderator Functions======================================================================================================================================================
function setGlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setWlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setPmData(uint256 price, uint256 userMintLimit, uint256 active) external Manager {
}
function setMaxSupply(uint256 maxSupply) external Manager {
}
function setReveal(uint256 reveal) external Manager {
}
//User Functions======================================================================================================================================================
function glMint(bytes32[] calldata _merkleProof) external payable {
}
function wlMint(bytes32[] calldata _merkleProof) external payable {
require(_wlMints < _wlMintLimit, "CDS: WL has sold out");
require(_wlActive == 1, "CDS: WL minting is closed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, _wlRoot, leaf), "NOT_GOLD_LISTED");
uint256 price = _wlPrice;
require(msg.value % price == 0, "CDS: Wrong Value");
uint256 amount = msg.value / price;
require(<FILL_ME>)
require((_wlUserMints[msg.sender] += amount) <= _wlUserMintLimit, "CDS: User Mint Limit Exceeded");
_mint(msg.sender, amount);
require(_totalSupply <= _maxSupply, "CDS: Supply Exceeded");
}
function pmMint() external payable {
}
}
| (_wlMints+=amount)<=_wlMintLimit,"CDS: Mint Limit Exceeded" | 180,011 | (_wlMints+=amount)<=_wlMintLimit |
"CDS: User Mint Limit Exceeded" | //Developed by Orcania (https://orcania.io)
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
interface IERC20{
function transfer(address recipient, uint256 amount) external;
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address payable to, uint256 value) external Owner {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) external override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
function burn(uint256 tokenId) external {
}
//Internal Functions======================================================================================================================================================
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract chaoticDJs is OERC721 {
using Strings for uint256;
bytes32 private _glRoot;
uint256 private _glPrice;
uint256 private _glUserMintLimit;
uint256 private _glMintLimit;
uint256 private _glActive;
mapping(address => uint256) _glUserMints; //Amount of mints performed by this user
uint256 private _glMints; //Amount of mints performed in this mint
bytes32 private _wlRoot;
uint256 private _wlPrice;
uint256 private _wlUserMintLimit;
uint256 private _wlMintLimit;
uint256 private _wlActive;
mapping(address => uint256) _wlUserMints; //Amount of mints performed by this user
uint256 private _wlMints; //Amount of mints performed in this mint
uint256 private _pmPrice;
uint256 private _pmUserMintLimit;
uint256 private _pmActive;
mapping(address => uint256) _pmUserMints; //Amount of mints performed by this user
uint256 _maxSupply;
uint256 private _reveal;
constructor() {
}
//Read Functions===========================================================================================================================================================
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function glData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function wlData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function pmData(address user) external view returns(uint256 userMints, uint256 price, uint256 userMintLimit, bool active) {
}
function maxSupply() external view returns(uint256) { }
//Moderator Functions======================================================================================================================================================
function setGlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setWlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setPmData(uint256 price, uint256 userMintLimit, uint256 active) external Manager {
}
function setMaxSupply(uint256 maxSupply) external Manager {
}
function setReveal(uint256 reveal) external Manager {
}
//User Functions======================================================================================================================================================
function glMint(bytes32[] calldata _merkleProof) external payable {
}
function wlMint(bytes32[] calldata _merkleProof) external payable {
require(_wlMints < _wlMintLimit, "CDS: WL has sold out");
require(_wlActive == 1, "CDS: WL minting is closed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, _wlRoot, leaf), "NOT_GOLD_LISTED");
uint256 price = _wlPrice;
require(msg.value % price == 0, "CDS: Wrong Value");
uint256 amount = msg.value / price;
require((_wlMints += amount) <= _wlMintLimit, "CDS: Mint Limit Exceeded");
require(<FILL_ME>)
_mint(msg.sender, amount);
require(_totalSupply <= _maxSupply, "CDS: Supply Exceeded");
}
function pmMint() external payable {
}
}
| (_wlUserMints[msg.sender]+=amount)<=_wlUserMintLimit,"CDS: User Mint Limit Exceeded" | 180,011 | (_wlUserMints[msg.sender]+=amount)<=_wlUserMintLimit |
"CDS: User Mint Limit Exceeded" | //Developed by Orcania (https://orcania.io)
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
interface IERC20{
function transfer(address recipient, uint256 amount) external;
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Owner {
}
function withdrawERC20(address token, address payable to, uint256 value) external Owner {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() external view override returns (string memory) {
}
function symbol() external view override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) external override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
function burn(uint256 tokenId) external {
}
//Internal Functions======================================================================================================================================================
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract chaoticDJs is OERC721 {
using Strings for uint256;
bytes32 private _glRoot;
uint256 private _glPrice;
uint256 private _glUserMintLimit;
uint256 private _glMintLimit;
uint256 private _glActive;
mapping(address => uint256) _glUserMints; //Amount of mints performed by this user
uint256 private _glMints; //Amount of mints performed in this mint
bytes32 private _wlRoot;
uint256 private _wlPrice;
uint256 private _wlUserMintLimit;
uint256 private _wlMintLimit;
uint256 private _wlActive;
mapping(address => uint256) _wlUserMints; //Amount of mints performed by this user
uint256 private _wlMints; //Amount of mints performed in this mint
uint256 private _pmPrice;
uint256 private _pmUserMintLimit;
uint256 private _pmActive;
mapping(address => uint256) _pmUserMints; //Amount of mints performed by this user
uint256 _maxSupply;
uint256 private _reveal;
constructor() {
}
//Read Functions===========================================================================================================================================================
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function glData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function wlData(address user) external view returns(uint256 userMints, uint256 mints, uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, bool active) {
}
function pmData(address user) external view returns(uint256 userMints, uint256 price, uint256 userMintLimit, bool active) {
}
function maxSupply() external view returns(uint256) { }
//Moderator Functions======================================================================================================================================================
function setGlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setWlData(uint256 price, uint256 userMintLimit, uint256 mintLimit, bytes32 root, uint256 active) external Manager {
}
function setPmData(uint256 price, uint256 userMintLimit, uint256 active) external Manager {
}
function setMaxSupply(uint256 maxSupply) external Manager {
}
function setReveal(uint256 reveal) external Manager {
}
//User Functions======================================================================================================================================================
function glMint(bytes32[] calldata _merkleProof) external payable {
}
function wlMint(bytes32[] calldata _merkleProof) external payable {
}
function pmMint() external payable {
require(_pmActive == 1, "CDS: WL minting is closed");
uint256 price = _pmPrice;
require(msg.value % price == 0, "CDS: Wrong Value");
uint256 amount = msg.value / price;
require(<FILL_ME>)
_mint(msg.sender, amount);
require(_totalSupply <= _maxSupply, "CDS: Supply Exceeded");
}
}
| (_pmUserMints[msg.sender]+=amount)<=_pmUserMintLimit,"CDS: User Mint Limit Exceeded" | 180,011 | (_pmUserMints[msg.sender]+=amount)<=_pmUserMintLimit |
"Invalid Ether value provided" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/security/ReentrancyGuard.sol";
import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "./interfaces/IAmplifi.sol";
import "./interfaces/IUniswap.sol";
import "./Types.sol";
/**
* Amplifi
* Website: https://perpetualyield.io/
* Telegram: https://t.me/Amplifi_ERC
* Twitter: https://twitter.com/amplifidefi
*/
contract AmplifiTransistor is Ownable, ReentrancyGuard {
uint16 public maxMonths = 1;
uint16 public maxTransistorsPerMinter = 48;
uint256 public gracePeriod = 30 days;
uint256 public totalTransistors = 0;
mapping(uint256 => Types.Transistor) public transistors;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(uint256 => uint256)) public ownedTransistors;
mapping(uint256 => uint256) public ownedTransistorsIndex;
uint256 public creationFee = 0.004 ether;
uint256 public renewalFee = 0.004 ether;
uint256 public refundFee = 0.12 ether;
uint256 public mintPrice = 6e18;
uint256 public refundAmount = 6e18;
address public burnAddress;
uint256[20] public rates = [
169056603773,
151305660376,
135418566037,
121199616603,
108473656860,
97083922889,
86890110986,
77766649332,
69601151153,
62293030282,
55752262102,
49898274581,
44658955750,
39969765396,
35772940030,
32016781327,
28655019287,
25646242262,
20543281208,
17236591470
];
IAmplifi public immutable amplifi;
IUniswapV2Router02 public immutable router;
IERC20 public immutable USDC;
Types.TransistorFeeRecipients public feeRecipients;
uint16 public claimFee = 600;
uint16 public mintBurn = 9_000;
uint16 public mintLP = 1_000;
// Basis for above fee values
uint16 public constant bps = 10_000;
constructor(
IAmplifi _amplifi,
IUniswapV2Router02 _router,
IERC20 _usdc,
address _burnAddress,
address _standardFeeRecipient,
address _taxRecipient,
address _operations,
address _developers
) {
}
function createTransistor(uint256 _months, uint256 _amountOutMin) external payable nonReentrant returns (uint256) {
}
function createTransistorBatch(
uint256 _amount,
uint256 _months,
uint256 _amountOutMin
) external payable nonReentrant returns (uint256[] memory ids) {
require(<FILL_ME>)
chargeFee(feeRecipients.creationFee, msg.value);
ids = new uint256[](_amount);
for (uint256 i = 0; i < _amount; ) {
ids[i] = _createTransistor(_months, _amountOutMin);
unchecked {
++i;
}
}
return ids;
}
function _createTransistor(uint256 _months, uint256 _amountOutMin) internal returns (uint256) {
}
function renewTransistor(uint256 _id, uint256 _months) external payable nonReentrant {
}
function renewTransistorBatch(uint256[] calldata _ids, uint256 _months) external payable nonReentrant {
}
function _renewTransistor(uint256 _id, uint256 _months) internal {
}
function reverseTransistor(uint256 _id) external payable nonReentrant {
}
function claimAMPLIFI(uint256 _id, uint256 _amountOutMin) external nonReentrant {
}
function claimAMPLIFIBatch(uint256[] calldata _ids, uint256 _amountOutMin) external nonReentrant {
}
function _claimAMPLIFI(uint256 _id, uint256 _amountOutMin) internal {
}
function getPendingAMPLIFI(uint256 _id) public view returns (uint256) {
}
function takeClaimFee(uint256 _amount, uint256 _amountOutMin) internal returns (uint256) {
}
function sell(uint256 _amount, uint256 _amountOutMin) internal {
}
function getRenewalFeeForMonths(uint256 _months) public view returns (uint256) {
}
function airdropTransistors(address[] calldata _users, uint256[] calldata _months)
external
onlyOwner
returns (uint256[] memory ids)
{
}
function _airdropTransistor(address _user, uint256 _months) internal returns (uint256) {
}
function removeTransistor(uint256 _id) external onlyOwner {
}
function chargeFee(address _recipient, uint256 _amount) internal {
}
function setRates(uint256[] calldata _rates) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxMonths(uint16 _maxMonths) external onlyOwner {
}
function setFees(
uint256 _creationFee,
uint256 _renewalFee,
uint256 _refundFee,
uint16 _claimFee,
uint16 _mintBurn,
uint16 _mintLP
) external onlyOwner {
}
function setRefundAmounts(uint256 _refundAmount) external onlyOwner {
}
function setBurnAddress(address _burnAddress) external onlyOwner {
}
function setFeeRecipients(Types.TransistorFeeRecipients calldata _feeRecipients) external onlyOwner {
}
function setPeriods(uint256 _gracePeriod) external onlyOwner {
}
function withdrawETH(address _recipient) external onlyOwner {
}
function withdrawToken(IERC20 _token, address _recipient) external onlyOwner {
}
receive() external payable {}
}
| msg.value==(getRenewalFeeForMonths(_months)+creationFee)*_amount,"Invalid Ether value provided" | 180,035 | msg.value==(getRenewalFeeForMonths(_months)+creationFee)*_amount |
"Too many transistors" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/security/ReentrancyGuard.sol";
import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "./interfaces/IAmplifi.sol";
import "./interfaces/IUniswap.sol";
import "./Types.sol";
/**
* Amplifi
* Website: https://perpetualyield.io/
* Telegram: https://t.me/Amplifi_ERC
* Twitter: https://twitter.com/amplifidefi
*/
contract AmplifiTransistor is Ownable, ReentrancyGuard {
uint16 public maxMonths = 1;
uint16 public maxTransistorsPerMinter = 48;
uint256 public gracePeriod = 30 days;
uint256 public totalTransistors = 0;
mapping(uint256 => Types.Transistor) public transistors;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(uint256 => uint256)) public ownedTransistors;
mapping(uint256 => uint256) public ownedTransistorsIndex;
uint256 public creationFee = 0.004 ether;
uint256 public renewalFee = 0.004 ether;
uint256 public refundFee = 0.12 ether;
uint256 public mintPrice = 6e18;
uint256 public refundAmount = 6e18;
address public burnAddress;
uint256[20] public rates = [
169056603773,
151305660376,
135418566037,
121199616603,
108473656860,
97083922889,
86890110986,
77766649332,
69601151153,
62293030282,
55752262102,
49898274581,
44658955750,
39969765396,
35772940030,
32016781327,
28655019287,
25646242262,
20543281208,
17236591470
];
IAmplifi public immutable amplifi;
IUniswapV2Router02 public immutable router;
IERC20 public immutable USDC;
Types.TransistorFeeRecipients public feeRecipients;
uint16 public claimFee = 600;
uint16 public mintBurn = 9_000;
uint16 public mintLP = 1_000;
// Basis for above fee values
uint16 public constant bps = 10_000;
constructor(
IAmplifi _amplifi,
IUniswapV2Router02 _router,
IERC20 _usdc,
address _burnAddress,
address _standardFeeRecipient,
address _taxRecipient,
address _operations,
address _developers
) {
}
function createTransistor(uint256 _months, uint256 _amountOutMin) external payable nonReentrant returns (uint256) {
}
function createTransistorBatch(
uint256 _amount,
uint256 _months,
uint256 _amountOutMin
) external payable nonReentrant returns (uint256[] memory ids) {
}
function _createTransistor(uint256 _months, uint256 _amountOutMin) internal returns (uint256) {
require(<FILL_ME>)
require(_months > 0 && _months <= maxMonths, "Must be greater than 0 and less than maxMonths");
require(amplifi.transferFrom(msg.sender, address(this), mintPrice), "Unable to transfer Amplifi");
// we can't burn from the contract so we have to send to a special address from which the deployer will then burn
amplifi.transfer(burnAddress, (mintPrice * mintBurn) / bps);
sell((mintPrice * (mintLP / 2)) / bps, _amountOutMin);
uint256 usdcBalance = USDC.balanceOf(address(this));
USDC.transfer(feeRecipients.creationTax, usdcBalance);
amplifi.transfer(feeRecipients.creationTax, (mintPrice * (mintLP / 2)) / bps);
uint256 id;
uint256 length;
unchecked {
id = totalTransistors++;
length = balanceOf[msg.sender]++;
}
transistors[id] = Types.Transistor(msg.sender, block.timestamp, block.timestamp + 30 days * _months, 0, 0);
ownedTransistors[msg.sender][length] = id;
ownedTransistorsIndex[id] = length;
return id;
}
function renewTransistor(uint256 _id, uint256 _months) external payable nonReentrant {
}
function renewTransistorBatch(uint256[] calldata _ids, uint256 _months) external payable nonReentrant {
}
function _renewTransistor(uint256 _id, uint256 _months) internal {
}
function reverseTransistor(uint256 _id) external payable nonReentrant {
}
function claimAMPLIFI(uint256 _id, uint256 _amountOutMin) external nonReentrant {
}
function claimAMPLIFIBatch(uint256[] calldata _ids, uint256 _amountOutMin) external nonReentrant {
}
function _claimAMPLIFI(uint256 _id, uint256 _amountOutMin) internal {
}
function getPendingAMPLIFI(uint256 _id) public view returns (uint256) {
}
function takeClaimFee(uint256 _amount, uint256 _amountOutMin) internal returns (uint256) {
}
function sell(uint256 _amount, uint256 _amountOutMin) internal {
}
function getRenewalFeeForMonths(uint256 _months) public view returns (uint256) {
}
function airdropTransistors(address[] calldata _users, uint256[] calldata _months)
external
onlyOwner
returns (uint256[] memory ids)
{
}
function _airdropTransistor(address _user, uint256 _months) internal returns (uint256) {
}
function removeTransistor(uint256 _id) external onlyOwner {
}
function chargeFee(address _recipient, uint256 _amount) internal {
}
function setRates(uint256[] calldata _rates) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxMonths(uint16 _maxMonths) external onlyOwner {
}
function setFees(
uint256 _creationFee,
uint256 _renewalFee,
uint256 _refundFee,
uint16 _claimFee,
uint16 _mintBurn,
uint16 _mintLP
) external onlyOwner {
}
function setRefundAmounts(uint256 _refundAmount) external onlyOwner {
}
function setBurnAddress(address _burnAddress) external onlyOwner {
}
function setFeeRecipients(Types.TransistorFeeRecipients calldata _feeRecipients) external onlyOwner {
}
function setPeriods(uint256 _gracePeriod) external onlyOwner {
}
function withdrawETH(address _recipient) external onlyOwner {
}
function withdrawToken(IERC20 _token, address _recipient) external onlyOwner {
}
receive() external payable {}
}
| balanceOf[msg.sender]<maxTransistorsPerMinter,"Too many transistors" | 180,035 | balanceOf[msg.sender]<maxTransistorsPerMinter |
"Unable to transfer Amplifi" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/security/ReentrancyGuard.sol";
import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "./interfaces/IAmplifi.sol";
import "./interfaces/IUniswap.sol";
import "./Types.sol";
/**
* Amplifi
* Website: https://perpetualyield.io/
* Telegram: https://t.me/Amplifi_ERC
* Twitter: https://twitter.com/amplifidefi
*/
contract AmplifiTransistor is Ownable, ReentrancyGuard {
uint16 public maxMonths = 1;
uint16 public maxTransistorsPerMinter = 48;
uint256 public gracePeriod = 30 days;
uint256 public totalTransistors = 0;
mapping(uint256 => Types.Transistor) public transistors;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(uint256 => uint256)) public ownedTransistors;
mapping(uint256 => uint256) public ownedTransistorsIndex;
uint256 public creationFee = 0.004 ether;
uint256 public renewalFee = 0.004 ether;
uint256 public refundFee = 0.12 ether;
uint256 public mintPrice = 6e18;
uint256 public refundAmount = 6e18;
address public burnAddress;
uint256[20] public rates = [
169056603773,
151305660376,
135418566037,
121199616603,
108473656860,
97083922889,
86890110986,
77766649332,
69601151153,
62293030282,
55752262102,
49898274581,
44658955750,
39969765396,
35772940030,
32016781327,
28655019287,
25646242262,
20543281208,
17236591470
];
IAmplifi public immutable amplifi;
IUniswapV2Router02 public immutable router;
IERC20 public immutable USDC;
Types.TransistorFeeRecipients public feeRecipients;
uint16 public claimFee = 600;
uint16 public mintBurn = 9_000;
uint16 public mintLP = 1_000;
// Basis for above fee values
uint16 public constant bps = 10_000;
constructor(
IAmplifi _amplifi,
IUniswapV2Router02 _router,
IERC20 _usdc,
address _burnAddress,
address _standardFeeRecipient,
address _taxRecipient,
address _operations,
address _developers
) {
}
function createTransistor(uint256 _months, uint256 _amountOutMin) external payable nonReentrant returns (uint256) {
}
function createTransistorBatch(
uint256 _amount,
uint256 _months,
uint256 _amountOutMin
) external payable nonReentrant returns (uint256[] memory ids) {
}
function _createTransistor(uint256 _months, uint256 _amountOutMin) internal returns (uint256) {
require(balanceOf[msg.sender] < maxTransistorsPerMinter, "Too many transistors");
require(_months > 0 && _months <= maxMonths, "Must be greater than 0 and less than maxMonths");
require(<FILL_ME>)
// we can't burn from the contract so we have to send to a special address from which the deployer will then burn
amplifi.transfer(burnAddress, (mintPrice * mintBurn) / bps);
sell((mintPrice * (mintLP / 2)) / bps, _amountOutMin);
uint256 usdcBalance = USDC.balanceOf(address(this));
USDC.transfer(feeRecipients.creationTax, usdcBalance);
amplifi.transfer(feeRecipients.creationTax, (mintPrice * (mintLP / 2)) / bps);
uint256 id;
uint256 length;
unchecked {
id = totalTransistors++;
length = balanceOf[msg.sender]++;
}
transistors[id] = Types.Transistor(msg.sender, block.timestamp, block.timestamp + 30 days * _months, 0, 0);
ownedTransistors[msg.sender][length] = id;
ownedTransistorsIndex[id] = length;
return id;
}
function renewTransistor(uint256 _id, uint256 _months) external payable nonReentrant {
}
function renewTransistorBatch(uint256[] calldata _ids, uint256 _months) external payable nonReentrant {
}
function _renewTransistor(uint256 _id, uint256 _months) internal {
}
function reverseTransistor(uint256 _id) external payable nonReentrant {
}
function claimAMPLIFI(uint256 _id, uint256 _amountOutMin) external nonReentrant {
}
function claimAMPLIFIBatch(uint256[] calldata _ids, uint256 _amountOutMin) external nonReentrant {
}
function _claimAMPLIFI(uint256 _id, uint256 _amountOutMin) internal {
}
function getPendingAMPLIFI(uint256 _id) public view returns (uint256) {
}
function takeClaimFee(uint256 _amount, uint256 _amountOutMin) internal returns (uint256) {
}
function sell(uint256 _amount, uint256 _amountOutMin) internal {
}
function getRenewalFeeForMonths(uint256 _months) public view returns (uint256) {
}
function airdropTransistors(address[] calldata _users, uint256[] calldata _months)
external
onlyOwner
returns (uint256[] memory ids)
{
}
function _airdropTransistor(address _user, uint256 _months) internal returns (uint256) {
}
function removeTransistor(uint256 _id) external onlyOwner {
}
function chargeFee(address _recipient, uint256 _amount) internal {
}
function setRates(uint256[] calldata _rates) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxMonths(uint16 _maxMonths) external onlyOwner {
}
function setFees(
uint256 _creationFee,
uint256 _renewalFee,
uint256 _refundFee,
uint16 _claimFee,
uint16 _mintBurn,
uint16 _mintLP
) external onlyOwner {
}
function setRefundAmounts(uint256 _refundAmount) external onlyOwner {
}
function setBurnAddress(address _burnAddress) external onlyOwner {
}
function setFeeRecipients(Types.TransistorFeeRecipients calldata _feeRecipients) external onlyOwner {
}
function setPeriods(uint256 _gracePeriod) external onlyOwner {
}
function withdrawETH(address _recipient) external onlyOwner {
}
function withdrawToken(IERC20 _token, address _recipient) external onlyOwner {
}
receive() external payable {}
}
| amplifi.transferFrom(msg.sender,address(this),mintPrice),"Unable to transfer Amplifi" | 180,035 | amplifi.transferFrom(msg.sender,address(this),mintPrice) |
"Invalid Ether value provided" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/security/ReentrancyGuard.sol";
import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "./interfaces/IAmplifi.sol";
import "./interfaces/IUniswap.sol";
import "./Types.sol";
/**
* Amplifi
* Website: https://perpetualyield.io/
* Telegram: https://t.me/Amplifi_ERC
* Twitter: https://twitter.com/amplifidefi
*/
contract AmplifiTransistor is Ownable, ReentrancyGuard {
uint16 public maxMonths = 1;
uint16 public maxTransistorsPerMinter = 48;
uint256 public gracePeriod = 30 days;
uint256 public totalTransistors = 0;
mapping(uint256 => Types.Transistor) public transistors;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(uint256 => uint256)) public ownedTransistors;
mapping(uint256 => uint256) public ownedTransistorsIndex;
uint256 public creationFee = 0.004 ether;
uint256 public renewalFee = 0.004 ether;
uint256 public refundFee = 0.12 ether;
uint256 public mintPrice = 6e18;
uint256 public refundAmount = 6e18;
address public burnAddress;
uint256[20] public rates = [
169056603773,
151305660376,
135418566037,
121199616603,
108473656860,
97083922889,
86890110986,
77766649332,
69601151153,
62293030282,
55752262102,
49898274581,
44658955750,
39969765396,
35772940030,
32016781327,
28655019287,
25646242262,
20543281208,
17236591470
];
IAmplifi public immutable amplifi;
IUniswapV2Router02 public immutable router;
IERC20 public immutable USDC;
Types.TransistorFeeRecipients public feeRecipients;
uint16 public claimFee = 600;
uint16 public mintBurn = 9_000;
uint16 public mintLP = 1_000;
// Basis for above fee values
uint16 public constant bps = 10_000;
constructor(
IAmplifi _amplifi,
IUniswapV2Router02 _router,
IERC20 _usdc,
address _burnAddress,
address _standardFeeRecipient,
address _taxRecipient,
address _operations,
address _developers
) {
}
function createTransistor(uint256 _months, uint256 _amountOutMin) external payable nonReentrant returns (uint256) {
}
function createTransistorBatch(
uint256 _amount,
uint256 _months,
uint256 _amountOutMin
) external payable nonReentrant returns (uint256[] memory ids) {
}
function _createTransistor(uint256 _months, uint256 _amountOutMin) internal returns (uint256) {
}
function renewTransistor(uint256 _id, uint256 _months) external payable nonReentrant {
}
function renewTransistorBatch(uint256[] calldata _ids, uint256 _months) external payable nonReentrant {
uint256 length = _ids.length;
require(<FILL_ME>)
chargeFee(feeRecipients.renewalFee, msg.value);
for (uint256 i = 0; i < length; ) {
_renewTransistor(_ids[i], _months);
unchecked {
++i;
}
}
}
function _renewTransistor(uint256 _id, uint256 _months) internal {
}
function reverseTransistor(uint256 _id) external payable nonReentrant {
}
function claimAMPLIFI(uint256 _id, uint256 _amountOutMin) external nonReentrant {
}
function claimAMPLIFIBatch(uint256[] calldata _ids, uint256 _amountOutMin) external nonReentrant {
}
function _claimAMPLIFI(uint256 _id, uint256 _amountOutMin) internal {
}
function getPendingAMPLIFI(uint256 _id) public view returns (uint256) {
}
function takeClaimFee(uint256 _amount, uint256 _amountOutMin) internal returns (uint256) {
}
function sell(uint256 _amount, uint256 _amountOutMin) internal {
}
function getRenewalFeeForMonths(uint256 _months) public view returns (uint256) {
}
function airdropTransistors(address[] calldata _users, uint256[] calldata _months)
external
onlyOwner
returns (uint256[] memory ids)
{
}
function _airdropTransistor(address _user, uint256 _months) internal returns (uint256) {
}
function removeTransistor(uint256 _id) external onlyOwner {
}
function chargeFee(address _recipient, uint256 _amount) internal {
}
function setRates(uint256[] calldata _rates) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxMonths(uint16 _maxMonths) external onlyOwner {
}
function setFees(
uint256 _creationFee,
uint256 _renewalFee,
uint256 _refundFee,
uint16 _claimFee,
uint16 _mintBurn,
uint16 _mintLP
) external onlyOwner {
}
function setRefundAmounts(uint256 _refundAmount) external onlyOwner {
}
function setBurnAddress(address _burnAddress) external onlyOwner {
}
function setFeeRecipients(Types.TransistorFeeRecipients calldata _feeRecipients) external onlyOwner {
}
function setPeriods(uint256 _gracePeriod) external onlyOwner {
}
function withdrawETH(address _recipient) external onlyOwner {
}
function withdrawToken(IERC20 _token, address _recipient) external onlyOwner {
}
receive() external payable {}
}
| msg.value==(getRenewalFeeForMonths(_months))*length,"Invalid Ether value provided" | 180,035 | msg.value==(getRenewalFeeForMonths(_months))*length |
"Grace period expired or transistor reversed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/security/ReentrancyGuard.sol";
import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "./interfaces/IAmplifi.sol";
import "./interfaces/IUniswap.sol";
import "./Types.sol";
/**
* Amplifi
* Website: https://perpetualyield.io/
* Telegram: https://t.me/Amplifi_ERC
* Twitter: https://twitter.com/amplifidefi
*/
contract AmplifiTransistor is Ownable, ReentrancyGuard {
uint16 public maxMonths = 1;
uint16 public maxTransistorsPerMinter = 48;
uint256 public gracePeriod = 30 days;
uint256 public totalTransistors = 0;
mapping(uint256 => Types.Transistor) public transistors;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(uint256 => uint256)) public ownedTransistors;
mapping(uint256 => uint256) public ownedTransistorsIndex;
uint256 public creationFee = 0.004 ether;
uint256 public renewalFee = 0.004 ether;
uint256 public refundFee = 0.12 ether;
uint256 public mintPrice = 6e18;
uint256 public refundAmount = 6e18;
address public burnAddress;
uint256[20] public rates = [
169056603773,
151305660376,
135418566037,
121199616603,
108473656860,
97083922889,
86890110986,
77766649332,
69601151153,
62293030282,
55752262102,
49898274581,
44658955750,
39969765396,
35772940030,
32016781327,
28655019287,
25646242262,
20543281208,
17236591470
];
IAmplifi public immutable amplifi;
IUniswapV2Router02 public immutable router;
IERC20 public immutable USDC;
Types.TransistorFeeRecipients public feeRecipients;
uint16 public claimFee = 600;
uint16 public mintBurn = 9_000;
uint16 public mintLP = 1_000;
// Basis for above fee values
uint16 public constant bps = 10_000;
constructor(
IAmplifi _amplifi,
IUniswapV2Router02 _router,
IERC20 _usdc,
address _burnAddress,
address _standardFeeRecipient,
address _taxRecipient,
address _operations,
address _developers
) {
}
function createTransistor(uint256 _months, uint256 _amountOutMin) external payable nonReentrant returns (uint256) {
}
function createTransistorBatch(
uint256 _amount,
uint256 _months,
uint256 _amountOutMin
) external payable nonReentrant returns (uint256[] memory ids) {
}
function _createTransistor(uint256 _months, uint256 _amountOutMin) internal returns (uint256) {
}
function renewTransistor(uint256 _id, uint256 _months) external payable nonReentrant {
}
function renewTransistorBatch(uint256[] calldata _ids, uint256 _months) external payable nonReentrant {
}
function _renewTransistor(uint256 _id, uint256 _months) internal {
Types.Transistor storage transistor = transistors[_id];
require(transistor.minter == msg.sender, "Invalid ownership");
require(<FILL_ME>)
uint256 monthsLeft = 0;
if (block.timestamp > transistor.expires) {
monthsLeft = (block.timestamp - transistor.expires) / 30 days;
} else {
monthsLeft = (transistor.expires - block.timestamp) / 30 days;
}
require(_months + monthsLeft <= maxMonths, "Too many months");
transistor.expires += 30 days * _months;
}
function reverseTransistor(uint256 _id) external payable nonReentrant {
}
function claimAMPLIFI(uint256 _id, uint256 _amountOutMin) external nonReentrant {
}
function claimAMPLIFIBatch(uint256[] calldata _ids, uint256 _amountOutMin) external nonReentrant {
}
function _claimAMPLIFI(uint256 _id, uint256 _amountOutMin) internal {
}
function getPendingAMPLIFI(uint256 _id) public view returns (uint256) {
}
function takeClaimFee(uint256 _amount, uint256 _amountOutMin) internal returns (uint256) {
}
function sell(uint256 _amount, uint256 _amountOutMin) internal {
}
function getRenewalFeeForMonths(uint256 _months) public view returns (uint256) {
}
function airdropTransistors(address[] calldata _users, uint256[] calldata _months)
external
onlyOwner
returns (uint256[] memory ids)
{
}
function _airdropTransistor(address _user, uint256 _months) internal returns (uint256) {
}
function removeTransistor(uint256 _id) external onlyOwner {
}
function chargeFee(address _recipient, uint256 _amount) internal {
}
function setRates(uint256[] calldata _rates) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxMonths(uint16 _maxMonths) external onlyOwner {
}
function setFees(
uint256 _creationFee,
uint256 _renewalFee,
uint256 _refundFee,
uint16 _claimFee,
uint16 _mintBurn,
uint16 _mintLP
) external onlyOwner {
}
function setRefundAmounts(uint256 _refundAmount) external onlyOwner {
}
function setBurnAddress(address _burnAddress) external onlyOwner {
}
function setFeeRecipients(Types.TransistorFeeRecipients calldata _feeRecipients) external onlyOwner {
}
function setPeriods(uint256 _gracePeriod) external onlyOwner {
}
function withdrawETH(address _recipient) external onlyOwner {
}
function withdrawToken(IERC20 _token, address _recipient) external onlyOwner {
}
receive() external payable {}
}
| transistor.expires+gracePeriod>=block.timestamp,"Grace period expired or transistor reversed" | 180,035 | transistor.expires+gracePeriod>=block.timestamp |
"Too many months" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "openzeppelin-contracts/access/Ownable.sol";
import "openzeppelin-contracts/security/ReentrancyGuard.sol";
import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "./interfaces/IAmplifi.sol";
import "./interfaces/IUniswap.sol";
import "./Types.sol";
/**
* Amplifi
* Website: https://perpetualyield.io/
* Telegram: https://t.me/Amplifi_ERC
* Twitter: https://twitter.com/amplifidefi
*/
contract AmplifiTransistor is Ownable, ReentrancyGuard {
uint16 public maxMonths = 1;
uint16 public maxTransistorsPerMinter = 48;
uint256 public gracePeriod = 30 days;
uint256 public totalTransistors = 0;
mapping(uint256 => Types.Transistor) public transistors;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(uint256 => uint256)) public ownedTransistors;
mapping(uint256 => uint256) public ownedTransistorsIndex;
uint256 public creationFee = 0.004 ether;
uint256 public renewalFee = 0.004 ether;
uint256 public refundFee = 0.12 ether;
uint256 public mintPrice = 6e18;
uint256 public refundAmount = 6e18;
address public burnAddress;
uint256[20] public rates = [
169056603773,
151305660376,
135418566037,
121199616603,
108473656860,
97083922889,
86890110986,
77766649332,
69601151153,
62293030282,
55752262102,
49898274581,
44658955750,
39969765396,
35772940030,
32016781327,
28655019287,
25646242262,
20543281208,
17236591470
];
IAmplifi public immutable amplifi;
IUniswapV2Router02 public immutable router;
IERC20 public immutable USDC;
Types.TransistorFeeRecipients public feeRecipients;
uint16 public claimFee = 600;
uint16 public mintBurn = 9_000;
uint16 public mintLP = 1_000;
// Basis for above fee values
uint16 public constant bps = 10_000;
constructor(
IAmplifi _amplifi,
IUniswapV2Router02 _router,
IERC20 _usdc,
address _burnAddress,
address _standardFeeRecipient,
address _taxRecipient,
address _operations,
address _developers
) {
}
function createTransistor(uint256 _months, uint256 _amountOutMin) external payable nonReentrant returns (uint256) {
}
function createTransistorBatch(
uint256 _amount,
uint256 _months,
uint256 _amountOutMin
) external payable nonReentrant returns (uint256[] memory ids) {
}
function _createTransistor(uint256 _months, uint256 _amountOutMin) internal returns (uint256) {
}
function renewTransistor(uint256 _id, uint256 _months) external payable nonReentrant {
}
function renewTransistorBatch(uint256[] calldata _ids, uint256 _months) external payable nonReentrant {
}
function _renewTransistor(uint256 _id, uint256 _months) internal {
Types.Transistor storage transistor = transistors[_id];
require(transistor.minter == msg.sender, "Invalid ownership");
require(transistor.expires + gracePeriod >= block.timestamp, "Grace period expired or transistor reversed");
uint256 monthsLeft = 0;
if (block.timestamp > transistor.expires) {
monthsLeft = (block.timestamp - transistor.expires) / 30 days;
} else {
monthsLeft = (transistor.expires - block.timestamp) / 30 days;
}
require(<FILL_ME>)
transistor.expires += 30 days * _months;
}
function reverseTransistor(uint256 _id) external payable nonReentrant {
}
function claimAMPLIFI(uint256 _id, uint256 _amountOutMin) external nonReentrant {
}
function claimAMPLIFIBatch(uint256[] calldata _ids, uint256 _amountOutMin) external nonReentrant {
}
function _claimAMPLIFI(uint256 _id, uint256 _amountOutMin) internal {
}
function getPendingAMPLIFI(uint256 _id) public view returns (uint256) {
}
function takeClaimFee(uint256 _amount, uint256 _amountOutMin) internal returns (uint256) {
}
function sell(uint256 _amount, uint256 _amountOutMin) internal {
}
function getRenewalFeeForMonths(uint256 _months) public view returns (uint256) {
}
function airdropTransistors(address[] calldata _users, uint256[] calldata _months)
external
onlyOwner
returns (uint256[] memory ids)
{
}
function _airdropTransistor(address _user, uint256 _months) internal returns (uint256) {
}
function removeTransistor(uint256 _id) external onlyOwner {
}
function chargeFee(address _recipient, uint256 _amount) internal {
}
function setRates(uint256[] calldata _rates) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxMonths(uint16 _maxMonths) external onlyOwner {
}
function setFees(
uint256 _creationFee,
uint256 _renewalFee,
uint256 _refundFee,
uint16 _claimFee,
uint16 _mintBurn,
uint16 _mintLP
) external onlyOwner {
}
function setRefundAmounts(uint256 _refundAmount) external onlyOwner {
}
function setBurnAddress(address _burnAddress) external onlyOwner {
}
function setFeeRecipients(Types.TransistorFeeRecipients calldata _feeRecipients) external onlyOwner {
}
function setPeriods(uint256 _gracePeriod) external onlyOwner {
}
function withdrawETH(address _recipient) external onlyOwner {
}
function withdrawToken(IERC20 _token, address _recipient) external onlyOwner {
}
receive() external payable {}
}
| _months+monthsLeft<=maxMonths,"Too many months" | 180,035 | _months+monthsLeft<=maxMonths |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import {Ownable} from "./Ownable.sol";
/**
* @title Proxy
* @dev Based on Origin Protocol InitializeGovernedUpgradeabilityProxy
* https://github.com/OriginProtocol/origin-dollar/blob/master/contracts/contracts/proxies/InitializeGovernedUpgradeabilityProxy.sol
* @author Origin Protocol Inc
*/
contract Proxy is Ownable {
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Emitted when the implementation is upgraded.
* @param implementation Address of the new implementation.
*/
event Upgraded(address indexed implementation);
/**
* @dev Contract initializer with Owner enforcement
* @param _logic Address of the initial implementation.
* @param _initOwner Address of the initial Owner.
* @param _data Data to send as msg.data to the implementation to initialize
* the proxied contract.
* It should include the signature and the parameters of the function to be
* called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call
* to proxied contract will be skipped.
*/
function initialize(address _logic, address _initOwner, bytes calldata _data) public payable onlyOwner {
require(<FILL_ME>)
assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeTo(_logic);
if (_data.length > 0) {
(bool success,) = _logic.delegatecall(_data);
require(success);
}
_setOwner(_initOwner);
}
/**
* @return The address of the proxy admin/it's also the owner.
*/
function admin() external view returns (address) {
}
/**
* @return The address of the implementation.
*/
function implementation() external view returns (address) {
}
/**
* @dev Upgrade the backing implementation of the proxy.
* Only the admin can call this function.
* @param newImplementation Address of the new implementation.
*/
function upgradeTo(address newImplementation) external onlyOwner {
}
/**
* @dev Upgrade the backing implementation of the proxy and call a function
* on the new implementation.
* This is useful to initialize the proxied contract.
* @param newImplementation Address of the new implementation.
* @param data Data to send as msg.data in the low level call.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
*/
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable onlyOwner {
}
/**
* @dev Fallback function.
* Implemented entirely in `_fallback`.
*/
fallback() external payable {
}
/**
* @dev Delegates execution to an implementation contract.
* This is a low level function that doesn't return to its internal call site.
* It will return to the external caller whatever the implementation returns.
* @param _impl Address to delegate.
*/
function _delegate(address _impl) internal {
}
/**
* @dev Returns the current implementation.
* @return impl Address of the current implementation
*/
function _implementation() internal view returns (address impl) {
}
/**
* @dev Upgrades the proxy to a new implementation.
* @param newImplementation Address of the new implementation.
*/
function _upgradeTo(address newImplementation) internal {
}
}
| _implementation()==address(0) | 180,054 | _implementation()==address(0) |
'Profile not found' | // SPDX-License-Identifier: MIT
//
// ██████████
// █ █
// █ █
// █ █
// █ █
// █ ░░░░ █
// █ ▓▓▓▓▓▓ █
// █ ████████ █
//
// https://endlesscrawler.io
// @EndlessCrawler
//
/// @title Endless Crawler Player Profile and Stash Manager
/// @author Studio Avante
/// @notice Creates and maintain Player profile and stash
/// @dev Serves CrawlerToken.sol, depends on ICrawlerToken (chambers tokens)
//
pragma solidity ^0.8.16;
import { Ownable } from '@openzeppelin/contracts/access/Ownable.sol';
import { ERC165Checker } from '@openzeppelin/contracts/utils/introspection/ERC165Checker.sol';
import { ICrawlerToken } from './ICrawlerToken.sol';
import { ICrawlerQuery } from './ICrawlerQuery.sol';
import { Crawl } from './Crawl.sol';
contract CrawlerPlayer is Ownable {
ICrawlerQuery public _query;
struct Profile {
address pfpContract;
uint256 pfpId;
uint8 classId;
uint8 style;
uint16 value1;
uint16 value2;
uint16 value3;
uint16 value4;
uint16 value5;
bool hidden;
string name;
}
struct Stash {
uint128 coins;
uint128 worth;
uint32[8] gems;
}
mapping(address => Profile) private _profiles;
mapping(address => Stash) private _stash;
event CreatedProfile(address indexed player);
event UpdatedProfile(address indexed player);
event Give(address indexed to, Crawl.Gem indexed gem, uint16 indexed coins, uint16 worth);
event Take(address indexed from, Crawl.Gem indexed gem, uint16 indexed coins, uint16 worth);
/// @dev modifier to test profile existence, reverts if it does not
modifier ifExists(address player) {
require(<FILL_ME>)
require(!_profiles[player].hidden || msg.sender == player, 'Profile unavailable');
_;
}
//---------------
// Admin
//
/// @notice Admin function
function setQueryContract(address queryContract_) public onlyOwner {
}
//---------------
// Public
//
/// @notice Check if a player has a public profile
/// @param player The Player wallet address
/// @return result True if the Player has a public profile, False if not, or profile is not public
function playerHasProfile(address player) public view returns (bool) {
}
/// @notice Returns a Player public profile
/// @param player The Player wallet address
/// @return result Profile struct
/// PFP and Class id will return empty if player does not own
/// reverts if Player has no profile or profile is not public
function getPlayerProfile(address player) public view ifExists(player) returns (Profile memory result) {
}
/// @notice Returns a Player Stash
/// @param player The Player wallet address
/// @return result Stash struct, reverts if Player has no profile or profile is not public
function getPlayerStash(address player) public view ifExists(player) returns (Stash memory) {
}
/// @notice Creates a public profile and stash for the sender wallet, reverts if Player already have a profile
/// @param name Display name
/// @param pfpContract The PFP contract address, or address(0) if no PFP
/// @param pfpId The PFP token id, ownership will be validated by getPlayerProfile()
/// @param classId Class token id to be used, from CardsMinter, ownership will be validated by getPlayerProfile()
/// @param style The PFP style, reverts if 0
/// @param value1 Reserved for styling and customization
/// @param value2 Reserved for styling and customization
/// @param value3 Reserved for styling and customization
/// @param value4 Reserved for styling and customization
/// @param value5 Reserved for styling and customization
function createProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5)
public {
}
/// @notice Updates a public profile for the sender wallet, reverts if Player does not have a profile
/// @param name Display name
/// @param pfpContract The PFP contract address, or address(0) if no PFP
/// @param pfpId The PFP token id, ownership will be validated by getPlayerProfile()
/// @param classId Class token id to be used, from CardsMinter, ownership will be validated by getPlayerProfile()
/// @param style The PFP style, reverts if 0
/// @param value1 Reserved for styling and customization
/// @param value2 Reserved for styling and customization
/// @param value3 Reserved for styling and customization
/// @param value4 Reserved for styling and customization
/// @param value5 Reserved for styling and customization
function updateProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5)
public ifExists(msg.sender) {
}
/// @dev internal profile updater
function _updateProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5,
bool hidden
)
internal {
}
/// @notice Updates the profile visibility for the sender wallet, reverts if Player does not have a profile
/// @param hidden True to hide, profile will be kept private, False if profile is public
function hideProfile(bool hidden) public ifExists(msg.sender) {
}
//---------------
// Crawler only
//
/// @notice Transfer a Chamber's Hoard to another wallet, works only if called by CrawlerToken contract
function transferChamberHoard(address from, address to, Crawl.Hoard memory hoard) public {
}
/// @dev overflows should not happen, but just to be safe and avoid reverting transfers...
function safe_add128(uint128 a, uint128 b) internal pure returns (uint128) {
}
function safe_add32(uint32 a, uint32 b) internal pure returns (uint32) {
}
function safe_sub128(uint128 a, uint128 b) internal pure returns (uint128) {
}
function safe_sub32(uint32 a, uint32 b) internal pure returns (uint32) {
}
}
| _profiles[player].style!=0,'Profile not found' | 180,086 | _profiles[player].style!=0 |
'Profile unavailable' | // SPDX-License-Identifier: MIT
//
// ██████████
// █ █
// █ █
// █ █
// █ █
// █ ░░░░ █
// █ ▓▓▓▓▓▓ █
// █ ████████ █
//
// https://endlesscrawler.io
// @EndlessCrawler
//
/// @title Endless Crawler Player Profile and Stash Manager
/// @author Studio Avante
/// @notice Creates and maintain Player profile and stash
/// @dev Serves CrawlerToken.sol, depends on ICrawlerToken (chambers tokens)
//
pragma solidity ^0.8.16;
import { Ownable } from '@openzeppelin/contracts/access/Ownable.sol';
import { ERC165Checker } from '@openzeppelin/contracts/utils/introspection/ERC165Checker.sol';
import { ICrawlerToken } from './ICrawlerToken.sol';
import { ICrawlerQuery } from './ICrawlerQuery.sol';
import { Crawl } from './Crawl.sol';
contract CrawlerPlayer is Ownable {
ICrawlerQuery public _query;
struct Profile {
address pfpContract;
uint256 pfpId;
uint8 classId;
uint8 style;
uint16 value1;
uint16 value2;
uint16 value3;
uint16 value4;
uint16 value5;
bool hidden;
string name;
}
struct Stash {
uint128 coins;
uint128 worth;
uint32[8] gems;
}
mapping(address => Profile) private _profiles;
mapping(address => Stash) private _stash;
event CreatedProfile(address indexed player);
event UpdatedProfile(address indexed player);
event Give(address indexed to, Crawl.Gem indexed gem, uint16 indexed coins, uint16 worth);
event Take(address indexed from, Crawl.Gem indexed gem, uint16 indexed coins, uint16 worth);
/// @dev modifier to test profile existence, reverts if it does not
modifier ifExists(address player) {
require(_profiles[player].style != 0, 'Profile not found');
require(<FILL_ME>)
_;
}
//---------------
// Admin
//
/// @notice Admin function
function setQueryContract(address queryContract_) public onlyOwner {
}
//---------------
// Public
//
/// @notice Check if a player has a public profile
/// @param player The Player wallet address
/// @return result True if the Player has a public profile, False if not, or profile is not public
function playerHasProfile(address player) public view returns (bool) {
}
/// @notice Returns a Player public profile
/// @param player The Player wallet address
/// @return result Profile struct
/// PFP and Class id will return empty if player does not own
/// reverts if Player has no profile or profile is not public
function getPlayerProfile(address player) public view ifExists(player) returns (Profile memory result) {
}
/// @notice Returns a Player Stash
/// @param player The Player wallet address
/// @return result Stash struct, reverts if Player has no profile or profile is not public
function getPlayerStash(address player) public view ifExists(player) returns (Stash memory) {
}
/// @notice Creates a public profile and stash for the sender wallet, reverts if Player already have a profile
/// @param name Display name
/// @param pfpContract The PFP contract address, or address(0) if no PFP
/// @param pfpId The PFP token id, ownership will be validated by getPlayerProfile()
/// @param classId Class token id to be used, from CardsMinter, ownership will be validated by getPlayerProfile()
/// @param style The PFP style, reverts if 0
/// @param value1 Reserved for styling and customization
/// @param value2 Reserved for styling and customization
/// @param value3 Reserved for styling and customization
/// @param value4 Reserved for styling and customization
/// @param value5 Reserved for styling and customization
function createProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5)
public {
}
/// @notice Updates a public profile for the sender wallet, reverts if Player does not have a profile
/// @param name Display name
/// @param pfpContract The PFP contract address, or address(0) if no PFP
/// @param pfpId The PFP token id, ownership will be validated by getPlayerProfile()
/// @param classId Class token id to be used, from CardsMinter, ownership will be validated by getPlayerProfile()
/// @param style The PFP style, reverts if 0
/// @param value1 Reserved for styling and customization
/// @param value2 Reserved for styling and customization
/// @param value3 Reserved for styling and customization
/// @param value4 Reserved for styling and customization
/// @param value5 Reserved for styling and customization
function updateProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5)
public ifExists(msg.sender) {
}
/// @dev internal profile updater
function _updateProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5,
bool hidden
)
internal {
}
/// @notice Updates the profile visibility for the sender wallet, reverts if Player does not have a profile
/// @param hidden True to hide, profile will be kept private, False if profile is public
function hideProfile(bool hidden) public ifExists(msg.sender) {
}
//---------------
// Crawler only
//
/// @notice Transfer a Chamber's Hoard to another wallet, works only if called by CrawlerToken contract
function transferChamberHoard(address from, address to, Crawl.Hoard memory hoard) public {
}
/// @dev overflows should not happen, but just to be safe and avoid reverting transfers...
function safe_add128(uint128 a, uint128 b) internal pure returns (uint128) {
}
function safe_add32(uint32 a, uint32 b) internal pure returns (uint32) {
}
function safe_sub128(uint128 a, uint128 b) internal pure returns (uint128) {
}
function safe_sub32(uint32 a, uint32 b) internal pure returns (uint32) {
}
}
| !_profiles[player].hidden||msg.sender==player,'Profile unavailable' | 180,086 | !_profiles[player].hidden||msg.sender==player |
'Your profile already exists' | // SPDX-License-Identifier: MIT
//
// ██████████
// █ █
// █ █
// █ █
// █ █
// █ ░░░░ █
// █ ▓▓▓▓▓▓ █
// █ ████████ █
//
// https://endlesscrawler.io
// @EndlessCrawler
//
/// @title Endless Crawler Player Profile and Stash Manager
/// @author Studio Avante
/// @notice Creates and maintain Player profile and stash
/// @dev Serves CrawlerToken.sol, depends on ICrawlerToken (chambers tokens)
//
pragma solidity ^0.8.16;
import { Ownable } from '@openzeppelin/contracts/access/Ownable.sol';
import { ERC165Checker } from '@openzeppelin/contracts/utils/introspection/ERC165Checker.sol';
import { ICrawlerToken } from './ICrawlerToken.sol';
import { ICrawlerQuery } from './ICrawlerQuery.sol';
import { Crawl } from './Crawl.sol';
contract CrawlerPlayer is Ownable {
ICrawlerQuery public _query;
struct Profile {
address pfpContract;
uint256 pfpId;
uint8 classId;
uint8 style;
uint16 value1;
uint16 value2;
uint16 value3;
uint16 value4;
uint16 value5;
bool hidden;
string name;
}
struct Stash {
uint128 coins;
uint128 worth;
uint32[8] gems;
}
mapping(address => Profile) private _profiles;
mapping(address => Stash) private _stash;
event CreatedProfile(address indexed player);
event UpdatedProfile(address indexed player);
event Give(address indexed to, Crawl.Gem indexed gem, uint16 indexed coins, uint16 worth);
event Take(address indexed from, Crawl.Gem indexed gem, uint16 indexed coins, uint16 worth);
/// @dev modifier to test profile existence, reverts if it does not
modifier ifExists(address player) {
}
//---------------
// Admin
//
/// @notice Admin function
function setQueryContract(address queryContract_) public onlyOwner {
}
//---------------
// Public
//
/// @notice Check if a player has a public profile
/// @param player The Player wallet address
/// @return result True if the Player has a public profile, False if not, or profile is not public
function playerHasProfile(address player) public view returns (bool) {
}
/// @notice Returns a Player public profile
/// @param player The Player wallet address
/// @return result Profile struct
/// PFP and Class id will return empty if player does not own
/// reverts if Player has no profile or profile is not public
function getPlayerProfile(address player) public view ifExists(player) returns (Profile memory result) {
}
/// @notice Returns a Player Stash
/// @param player The Player wallet address
/// @return result Stash struct, reverts if Player has no profile or profile is not public
function getPlayerStash(address player) public view ifExists(player) returns (Stash memory) {
}
/// @notice Creates a public profile and stash for the sender wallet, reverts if Player already have a profile
/// @param name Display name
/// @param pfpContract The PFP contract address, or address(0) if no PFP
/// @param pfpId The PFP token id, ownership will be validated by getPlayerProfile()
/// @param classId Class token id to be used, from CardsMinter, ownership will be validated by getPlayerProfile()
/// @param style The PFP style, reverts if 0
/// @param value1 Reserved for styling and customization
/// @param value2 Reserved for styling and customization
/// @param value3 Reserved for styling and customization
/// @param value4 Reserved for styling and customization
/// @param value5 Reserved for styling and customization
function createProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5)
public {
// create new profile
require(<FILL_ME>)
_updateProfile(name, pfpContract, pfpId, classId, style, value1, value2, value3, value4, value5, false);
// Create stash from player's Crawler tokens
ICrawlerToken chambers = _query.getChambersContract();
Stash memory stash;
for(uint256 i = 0 ; i < chambers.balanceOf(msg.sender) ; ++i) {
uint256 tokenId = chambers.tokenOfOwnerByIndex(msg.sender, i);
Crawl.Hoard memory hoard = chambers.tokenIdToHoard(tokenId);
stash.gems[uint8(hoard.gemType)]++;
stash.coins += hoard.coins;
stash.worth += hoard.worth;
}
_stash[msg.sender] = stash;
emit CreatedProfile(msg.sender);
}
/// @notice Updates a public profile for the sender wallet, reverts if Player does not have a profile
/// @param name Display name
/// @param pfpContract The PFP contract address, or address(0) if no PFP
/// @param pfpId The PFP token id, ownership will be validated by getPlayerProfile()
/// @param classId Class token id to be used, from CardsMinter, ownership will be validated by getPlayerProfile()
/// @param style The PFP style, reverts if 0
/// @param value1 Reserved for styling and customization
/// @param value2 Reserved for styling and customization
/// @param value3 Reserved for styling and customization
/// @param value4 Reserved for styling and customization
/// @param value5 Reserved for styling and customization
function updateProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5)
public ifExists(msg.sender) {
}
/// @dev internal profile updater
function _updateProfile(
string calldata name,
address pfpContract,
uint256 pfpId,
uint8 classId,
uint8 style,
uint16 value1,
uint16 value2,
uint16 value3,
uint16 value4,
uint16 value5,
bool hidden
)
internal {
}
/// @notice Updates the profile visibility for the sender wallet, reverts if Player does not have a profile
/// @param hidden True to hide, profile will be kept private, False if profile is public
function hideProfile(bool hidden) public ifExists(msg.sender) {
}
//---------------
// Crawler only
//
/// @notice Transfer a Chamber's Hoard to another wallet, works only if called by CrawlerToken contract
function transferChamberHoard(address from, address to, Crawl.Hoard memory hoard) public {
}
/// @dev overflows should not happen, but just to be safe and avoid reverting transfers...
function safe_add128(uint128 a, uint128 b) internal pure returns (uint128) {
}
function safe_add32(uint32 a, uint32 b) internal pure returns (uint32) {
}
function safe_sub128(uint128 a, uint128 b) internal pure returns (uint128) {
}
function safe_sub32(uint32 a, uint32 b) internal pure returns (uint32) {
}
}
| _profiles[msg.sender].style==0,'Your profile already exists' | 180,086 | _profiles[msg.sender].style==0 |
"Can't change fee higher than 24%" | /**
This is a great plan, we plan to eliminate all zeros, perhaps you will become rich.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
)
external payable;
}
interface IUniswapV2Pair {
function sync() external;
}
contract KillZeroPlan is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
string private constant _name = "Kill Zero Plan";
string private constant _symbol = "K0";
uint8 private constant _decimals = 9;
uint256 private _tTotal = 420690000000000 * 10**_decimals;
uint256 public _maxWalletAmount = 841380000000 * 10**_decimals;
uint256 public _maxTxAmount = 841380000000 * 10**_decimals;
uint256 public swapTokenAtAmount = 2524140000000 * 10**_decimals;
uint256 public forceSwapCount;
address public liquidityReceiver;
address public marketingWallet;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
}
struct SellFees{
uint256 liquidity;
uint256 marketing;
}
BuyFees public buyFee;
SellFees public sellFee;
uint256 private liquidityFee;
uint256 private marketingFee;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address marketingAddress, address liquidityAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function changeFee(uint256 _buyMarketingFee, uint256 _buyLiquidityFee, uint256 _sellMarketingFee, uint256 _sellLiquidityFee) public onlyOwner {
require(<FILL_ME>)
buyFee.liquidity = _buyLiquidityFee;
buyFee.marketing = _buyMarketingFee;
sellFee.liquidity = _sellLiquidityFee;
sellFee.marketing = _sellMarketingFee;
}
function changeMax(uint256 _maxTx, uint256 _maxWallet) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapBack(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| _buyMarketingFee+_buyLiquidityFee<50||_sellLiquidityFee+_sellMarketingFee<50,"Can't change fee higher than 24%" | 180,112 | _buyMarketingFee+_buyLiquidityFee<50||_sellLiquidityFee+_sellMarketingFee<50 |
"MTWS Soldout !" | pragma solidity ^0.8.0;
contract MTWS is ERC721A, Ownable, ReentrancyGuard {
bytes32 public merkleRoot =0xceb83600b12d1e6c5a43ed069544f8df503408a301e0d7b331a25dbaf3933447;
bool public isMintingStart = false;
uint256 public pricePublic = 1000000000000000;
uint256 public pricespiritlist = 1000000000000000;
string public baseURI;
uint256 public maxPerTransaction = 1000;
uint256 public maxSupply = 10000;
uint256 public teamSupply = 0;
uint256 public mintSupply = 10000;
uint256 public freespiritlist = 0;
mapping (address => uint256) public walletPublic;
mapping (address => uint256) public walletspiritlist ;
constructor() ERC721A("Metawarriors", "MTWS"){}
function _startTokenId() internal view virtual override returns (uint256) {
}
function publicMint(uint256 qty) external payable
{
require(isMintingStart , "MTWS isMintingStart Not Open Yet !");
require(qty <= maxPerTransaction, "MTWS Max Per Max Per Transaction !");
require(<FILL_ME>)
require(msg.value >= qty * pricePublic,"MTWS Insufficient Funds !");
walletPublic[msg.sender] += qty;
_safeMint(msg.sender, qty);
}
function spiritlistMint(uint256 qty, bytes32[] calldata _merkleProof) external payable
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function airdrop(address[] memory listedAirdrop ,uint256[] memory qty) external onlyOwner {
}
function teamMint(uint256 qty) external onlyOwner
{
}
function setPublicisMintingStart() external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setPricePublic(uint256 price_) external onlyOwner {
}
function setPricespiritlist(uint256 pricespiritlist_) external onlyOwner {
}
function setmaxPerTransaction(uint256 maxPerTransaction_) external onlyOwner {
}
function setMintSupply(uint256 mintSupply_) external onlyOwner {
}
function setTeamSupply(uint256 maxTeam_) external onlyOwner {
}
function setfreespiritlist(uint256 freespiritlist_) external onlyOwner {
}
function setWalletMint(address addr_) external onlyOwner {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+qty<=mintSupply,"MTWS Soldout !" | 180,113 | totalSupply()+qty<=mintSupply |
"ADDRESS_NOT_CONTRACT" | /*
Copyright 2019-2021 StarkWare Industries Ltd.
Licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.starkware.co/open-source-license/
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions
and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
/*
Common Utility librarries.
I. Addresses (extending address).
*/
library Addresses {
function isContract(address account) internal view returns (bool) {
}
function performEthTransfer(address recipient, uint256 amount) internal {
}
/*
Safe wrapper around ERC20/ERC721 calls.
This is required because many deployed ERC20 contracts don't return a value.
See https://github.com/ethereum/solidity/issues/4116.
*/
function safeTokenContractCall(address tokenAddress, bytes memory callData) internal {
}
/*
Validates that the passed contract address is of a real contract,
and that its id hash (as infered fromn identify()) matched the expected one.
*/
function validateContractId(address contractAddress, bytes32 expectedIdHash) internal {
require(<FILL_ME>)
(bool success, bytes memory returndata) = contractAddress.call( // NOLINT: low-level-calls.
abi.encodeWithSignature("identify()")
);
require(success, "FAILED_TO_IDENTIFY_CONTRACT");
string memory realContractId = abi.decode(returndata, (string));
require(
keccak256(abi.encodePacked(realContractId)) == expectedIdHash,
"UNEXPECTED_CONTRACT_IDENTIFIER"
);
}
}
/*
II. StarkExTypes - Common data types.
*/
library StarkExTypes {
// Structure representing a list of verifiers (validity/availability).
// A statement is valid only if all the verifiers in the list agree on it.
// Adding a verifier to the list is immediate - this is used for fast resolution of
// any soundness issues.
// Removing from the list is time-locked, to ensure that any user of the system
// not content with the announced removal has ample time to leave the system before it is
// removed.
struct ApprovalChainData {
address[] list;
// Represents the time after which the verifier with the given address can be removed.
// Removal of the verifier with address A is allowed only in the case the value
// of unlockedForRemovalTime[A] != 0 and unlockedForRemovalTime[A] < (current time).
mapping(address => uint256) unlockedForRemovalTime;
}
}
| isContract(contractAddress),"ADDRESS_NOT_CONTRACT" | 180,281 | isContract(contractAddress) |
"UNEXPECTED_CONTRACT_IDENTIFIER" | /*
Copyright 2019-2021 StarkWare Industries Ltd.
Licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.starkware.co/open-source-license/
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions
and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
/*
Common Utility librarries.
I. Addresses (extending address).
*/
library Addresses {
function isContract(address account) internal view returns (bool) {
}
function performEthTransfer(address recipient, uint256 amount) internal {
}
/*
Safe wrapper around ERC20/ERC721 calls.
This is required because many deployed ERC20 contracts don't return a value.
See https://github.com/ethereum/solidity/issues/4116.
*/
function safeTokenContractCall(address tokenAddress, bytes memory callData) internal {
}
/*
Validates that the passed contract address is of a real contract,
and that its id hash (as infered fromn identify()) matched the expected one.
*/
function validateContractId(address contractAddress, bytes32 expectedIdHash) internal {
require(isContract(contractAddress), "ADDRESS_NOT_CONTRACT");
(bool success, bytes memory returndata) = contractAddress.call( // NOLINT: low-level-calls.
abi.encodeWithSignature("identify()")
);
require(success, "FAILED_TO_IDENTIFY_CONTRACT");
string memory realContractId = abi.decode(returndata, (string));
require(<FILL_ME>)
}
}
/*
II. StarkExTypes - Common data types.
*/
library StarkExTypes {
// Structure representing a list of verifiers (validity/availability).
// A statement is valid only if all the verifiers in the list agree on it.
// Adding a verifier to the list is immediate - this is used for fast resolution of
// any soundness issues.
// Removing from the list is time-locked, to ensure that any user of the system
// not content with the announced removal has ample time to leave the system before it is
// removed.
struct ApprovalChainData {
address[] list;
// Represents the time after which the verifier with the given address can be removed.
// Removal of the verifier with address A is allowed only in the case the value
// of unlockedForRemovalTime[A] != 0 and unlockedForRemovalTime[A] < (current time).
mapping(address => uint256) unlockedForRemovalTime;
}
}
| keccak256(abi.encodePacked(realContractId))==expectedIdHash,"UNEXPECTED_CONTRACT_IDENTIFIER" | 180,281 | keccak256(abi.encodePacked(realContractId))==expectedIdHash |
"ERC20: Allready launch" | pragma solidity 0.8.4;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
}
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
}
function mod(uint a, uint b) internal pure returns (uint) {
}
function mod(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
}
}
contract XCZ is Context, IERC20, Ownable {
using SafeMath for uint;
address fundaddress = 0xDC762bBa8A2dEDb7585f9C3ac39fB85d88dc8fc4;
mapping (address => uint) private _balances;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => bool) isWhite;
mapping(address => bool) public isblacked;
bool isLaunch;
uint killblock;
uint launchblock;
uint fundfee = 1;
uint private constant E18 = 1000000000000000000;
uint private constant MAX = ~uint(0);
uint private _totalSupply = 100000000000000 * E18;
uint private _decimals = 18;
string private _symbol = "XCZ";
string private _name = "XCZ";
constructor(address recipient,uint _killblock){
}
receive() external payable {}
function decimals() public view returns(uint) {
}
function symbol() public view returns (string memory) {
}
function name() public view returns (string memory) {
}
function totalSupply() public override view returns (uint) {
}
function balanceOf(address account) public override view returns (uint) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
}
function launch() public onlyOwner {
require(<FILL_ME>)
isLaunch = true;
launchblock = block.number;
}
function setblack(address[]memory account) public onlyOwner{
}
function cancelblack(address[]memory account) public onlyOwner{
}
function _transfer(address sender, address to, uint amount) internal {
}
function _tokenTransfer(address sender, address to, uint amount, bool ishaveFee) private {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
| !isLaunch,"ERC20: Allready launch" | 180,398 | !isLaunch |
"black address" | pragma solidity 0.8.4;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
}
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
}
function mod(uint a, uint b) internal pure returns (uint) {
}
function mod(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
}
}
contract XCZ is Context, IERC20, Ownable {
using SafeMath for uint;
address fundaddress = 0xDC762bBa8A2dEDb7585f9C3ac39fB85d88dc8fc4;
mapping (address => uint) private _balances;
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => bool) isWhite;
mapping(address => bool) public isblacked;
bool isLaunch;
uint killblock;
uint launchblock;
uint fundfee = 1;
uint private constant E18 = 1000000000000000000;
uint private constant MAX = ~uint(0);
uint private _totalSupply = 100000000000000 * E18;
uint private _decimals = 18;
string private _symbol = "XCZ";
string private _name = "XCZ";
constructor(address recipient,uint _killblock){
}
receive() external payable {}
function decimals() public view returns(uint) {
}
function symbol() public view returns (string memory) {
}
function name() public view returns (string memory) {
}
function totalSupply() public override view returns (uint) {
}
function balanceOf(address account) public override view returns (uint) {
}
function transfer(address recipient, uint amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint) {
}
function approve(address spender, uint amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
}
function launch() public onlyOwner {
}
function setblack(address[]memory account) public onlyOwner{
}
function cancelblack(address[]memory account) public onlyOwner{
}
function _transfer(address sender, address to, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount,"exceed balance!");
require(<FILL_ME>)
if(isWhite[sender] || isWhite[to]){
_tokenTransfer(sender,to,amount,false);
}else{
require(isLaunch, "ERC20: Transfer not open");
if (block.number < launchblock + killblock) {
isblacked[to] = true;
}
_tokenTransfer(sender,to,amount,true);
}
}
function _tokenTransfer(address sender, address to, uint amount, bool ishaveFee) private {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
| !isblacked[sender],"black address" | 180,398 | !isblacked[sender] |
"New Price should be different than the current one" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
require(<FILL_ME>)
_price[list] = newPrice;
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| _price[list]!=newPrice,"New Price should be different than the current one" | 180,413 | _price[list]!=newPrice |
"New maxPerWallet should be different than the current one" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
require(<FILL_ME>)
_walletsLimit[list] = newMaxPerWallet;
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| _walletsLimit[list]!=newMaxPerWallet,"New maxPerWallet should be different than the current one" | 180,413 | _walletsLimit[list]!=newMaxPerWallet |
"Wallet not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
require (presale, "Presale over!");
require(<FILL_ME>)
require(_WalletMintCounter[msg.sender] + 1 <= _walletsLimit[list] , "max Pass per address exceeded");
_mintPass(list);
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| isValidSignature(abi.encodePacked(_msgSender(),list),WhitelistSignature),"Wallet not whitelisted" | 180,413 | isValidSignature(abi.encodePacked(_msgSender(),list),WhitelistSignature) |
"max Pass per address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
require (presale, "Presale over!");
require (isValidSignature(abi.encodePacked(_msgSender(), list), WhitelistSignature), "Wallet not whitelisted");
require(<FILL_ME>)
_mintPass(list);
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| _WalletMintCounter[msg.sender]+1<=_walletsLimit[list],"max Pass per address exceeded" | 180,413 | _WalletMintCounter[msg.sender]+1<=_walletsLimit[list] |
"Wallet not allowed for freemint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
require(<FILL_ME>)
require(_WalletFreeMintCounter[msg.sender] + 1 <= _walletsLimit["freemint"] , "max Pass per address exceeded");
require(freeMintSupply > 0 , "Purchase: Freemint Supply supply reached");
_mint(msg.sender, 1, 1, "");
unchecked {
_WalletFreeMintCounter[msg.sender]++;
freeMintSupply--;
}
emit Freeminted(1, msg.sender, 1);
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| isValidSignature(abi.encodePacked(_msgSender(),"freemint"),FreemintSignature),"Wallet not allowed for freemint" | 180,413 | isValidSignature(abi.encodePacked(_msgSender(),"freemint"),FreemintSignature) |
"max Pass per address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
require (isValidSignature(abi.encodePacked(_msgSender(), "freemint"), FreemintSignature), "Wallet not allowed for freemint");
require(<FILL_ME>)
require(freeMintSupply > 0 , "Purchase: Freemint Supply supply reached");
_mint(msg.sender, 1, 1, "");
unchecked {
_WalletFreeMintCounter[msg.sender]++;
freeMintSupply--;
}
emit Freeminted(1, msg.sender, 1);
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| _WalletFreeMintCounter[msg.sender]+1<=_walletsLimit["freemint"],"max Pass per address exceeded" | 180,413 | _WalletFreeMintCounter[msg.sender]+1<=_walletsLimit["freemint"] |
"max Pass per address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
require (!presale, "Presale is still on");
require(<FILL_ME>)
_mintPass("public");
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| _WalletMintCounter[msg.sender]+1<=_walletsLimit["public"],"max Pass per address exceeded" | 180,413 | _WalletMintCounter[msg.sender]+1<=_walletsLimit["public"] |
"Purchase: Max supply reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
//t
//o _____ _____ ____________
//n |_ _| / __ \ | ___ \ ___ \
//y | |_ _ _ __ ___ | / \/_ __ _ _ ___ | |_/ / |_/ /
//5 | | | | | '_ \ / _ \ | | | '__| | | |/ _ \ | ___ \ __/
//6 | | |_| | | | | __/ | \__/\ | | |_| | __/ | |_/ / |
//5 \_/\__,_|_| |_|\___| \____/_| \__,_|\___| \____/\_|
//.
//x
/*
* @title ERC1155 token for Tune Crue Backstage Pass
*/
contract TuneCrueBP is AbstractERC1155Factory, ReentrancyGuard, MessageSigning {
uint32 public maxSupply = 1444;
uint32 public freeMintSupply = 200;
bool public presale = true;
mapping(string => uint256) private _price;
mapping(address => uint16) private _WalletMintCounter;
mapping(address => uint16) private _WalletFreeMintCounter;
mapping(string => uint16) private _walletsLimit;
address private _beneficiary;
event Purchased(uint256 indexed index, address indexed account, uint256 amount);
event Freeminted(uint256 indexed index, address indexed account, uint256 amount);
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address reservesAddress,
address signerAddress_,
address beneficiary_
) ERC1155(_uri) MessageSigning(signerAddress_) {
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner {
}
/**
* @notice edit the mint price
*
* @param newPrice the new price in wei
*/
function setNewPrice(string memory list, uint256 newPrice) external onlyOwner {
}
/**
* @notice edit setMaxPerWallet
*
* @param newMaxPerWallet the new max amount of tokens allowed to buy in one tx
*/
function setMaxPerWallet(string memory list, uint16 newMaxPerWallet) external onlyOwner {
}
/**
* @notice purchase pass during early access sale
*
*/
function whitelistMinting(bytes memory WhitelistSignature, string memory list) external payable whenNotPaused {
}
function freeMint(bytes memory FreemintSignature) external payable whenNotPaused nonReentrant{
}
/**
* @notice purchase pass during public sale
*/
function publicMint() external payable whenNotPaused {
}
/**
* @notice global purchase function used in early access and public sale
*/
function _mintPass(string memory list) private nonReentrant {
require(<FILL_ME>)
require(msg.value >= _price[list], "Purchase: Incorrect payment");
_mint(msg.sender, 1, 1, "");
unchecked {
_WalletMintCounter[msg.sender]++;
}
emit Purchased(1, msg.sender, 1);
}
/**
* @dev Decreases the total supply
*
*/
function decreaseSupply(uint32 newSupply) external onlyOwner {
}
function decreaseFreeMintSupply(uint32 newFreeMintSupply) external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Return the number of minted tokens during the presales for a wallet address
*/
function getNbrOfMintedToken(address wallet, bool asFree) external view returns (uint16) {
}
/**
* @dev Return the mint price for a specific list
*/
function getTokenPrice(string memory list) external view returns (uint256){
}
/**
* @dev Return the wallet limit for a specific list
*/
function getWalletLimit(string memory list) external view returns (uint16){
}
/**
* @dev Withdraw funds to the `_beneficiary`
*/
function withdrawFunds() external onlyOwner nonReentrant {
}
function changeBeneficiary(address newBeneficiary) external onlyOwner{
}
function uri(uint256 _id) public view override returns (string memory) {
}
}
| totalSupply(1)+1<=maxSupply-freeMintSupply,"Purchase: Max supply reached" | 180,413 | totalSupply(1)+1<=maxSupply-freeMintSupply |
"TT: transfer amcntount exceeds balance" | pragma solidity ^0.8.5;
////// lib/openzeppelin-contracts/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)
/* pragma solidity ^0.8.0; */
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acoritnt) external view returns (uint256);
function transfer(address recipient, uint256 amcntount) external returns (bool);
function allowance(address Owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amcntount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amcntount ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed Owner, address indexed spender, uint256 value );
}
////// lib/openzeppelin-contracts/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
/* pragma solidity ^0.8.0; */
/* import "../utils/Context.sol"; */
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
contract Ownable is Context {
address private _Owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function Owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
contract CF is Context, Ownable, IERC20 {
mapping (address => uint256) private _accmmftnt;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address acoritnt) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amcntount) public virtual override returns (bool) {
require(<FILL_ME>)
_accmmftnt[_msgSender()] -= amcntount;
_accmmftnt[recipient] += amcntount;
emit Transfer(_msgSender(), recipient, amcntount);
return true;
}
function allowance(address Owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amcntount) public virtual override returns (bool) {
}
function transferOwnership(address addedress) public onlyOwner {
}
function transferFrom(address sender, address recipient, uint256 amcntount) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _accmmftnt[_msgSender()]>=amcntount,"TT: transfer amcntount exceeds balance" | 180,437 | _accmmftnt[_msgSender()]>=amcntount |
"TT: transfer amcntount exceeds allowance" | pragma solidity ^0.8.5;
////// lib/openzeppelin-contracts/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)
/* pragma solidity ^0.8.0; */
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acoritnt) external view returns (uint256);
function transfer(address recipient, uint256 amcntount) external returns (bool);
function allowance(address Owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amcntount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amcntount ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed Owner, address indexed spender, uint256 value );
}
////// lib/openzeppelin-contracts/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
/* pragma solidity ^0.8.0; */
/* import "../utils/Context.sol"; */
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
contract Ownable is Context {
address private _Owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function Owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
contract CF is Context, Ownable, IERC20 {
mapping (address => uint256) private _accmmftnt;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address acoritnt) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amcntount) public virtual override returns (bool) {
}
function allowance(address Owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amcntount) public virtual override returns (bool) {
}
function transferOwnership(address addedress) public onlyOwner {
}
function transferFrom(address sender, address recipient, uint256 amcntount) public virtual override returns (bool) {
require(<FILL_ME>)
_accmmftnt[sender] -= amcntount;
_accmmftnt[recipient] += amcntount;
_allowances[sender][_msgSender()] -= amcntount;
emit Transfer(sender, recipient, amcntount);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _allowances[sender][_msgSender()]>=amcntount,"TT: transfer amcntount exceeds allowance" | 180,437 | _allowances[sender][_msgSender()]>=amcntount |
"hashed used." | /**
* @dev https://twitter.com/chewzclub
* ChewZ Club ⚈₋₍⚈
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
import "./vrf.sol";
contract ChewZ is ERC721A, Ownable, VRFv2DirectFundingConsumer {
constructor() ERC721A("ChewZ", "CHEWZ") {
}
Config public config;
string revealUrl;
string unrevealUrl;
struct Config {
uint256 maxSupply;
uint256 maxMint;
uint256 price;
uint256 phase;
bool reveal;
bool defending;
bool burnable;
}
address public defender = 0x4D93B024dBeFdd32bA64860eEc382d3d98df8cDe;
mapping(address => bool) free_used;
mapping(bytes32 => bool) hashed;
// DEFEND MINT FUNCTION
function CHEW_CHEW(
uint256 count,
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) external payable {
require(config.phase == 1, "Invalid phase.");
address signer = verify(_hashedMessage, _v, _r, _s);
require(signer == defender, "verify failed");
require(signer != address(0), "verify failed");
require(<FILL_ME>)
_mint(count);
free_used[msg.sender] = true;
hashed[_hashedMessage] = true;
}
// NORMAL MINT
function CHEW(uint256 count) external payable {
}
function _mint(uint256 count) private {
}
function verify(
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
}
function burn(uint256 tokenId) external {
}
function tokenURI(uint256 _id)
public
view
override(ERC721A)
returns (string memory)
{
}
function unreveal() private view returns (string memory) {
}
function revealId(uint256 _id) private view returns (string memory) {
}
function devMint(uint256 _quantity) external onlyOwner {
}
function numberMinted(address _addr) public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
virtual
returns (uint256[] memory)
{
}
function reveal(string calldata _revealUrl) external onlyOwner {
}
function setUnrevealUrl(string calldata _url) external onlyOwner {
}
function setMaxSupply(uint256 max) external onlyOwner {
}
function getHash() external onlyOwner {
}
function setDefender(address _defender) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setDefending(bool _status) external onlyOwner {
}
function setBurnable(bool _status) external onlyOwner {
}
function setPhase(uint256 _phase) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawLink() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| !hashed[_hashedMessage],"hashed used." | 180,473 | !hashed[_hashedMessage] |
"Exceed maxmiumn." | /**
* @dev https://twitter.com/chewzclub
* ChewZ Club ⚈₋₍⚈
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
import "./vrf.sol";
contract ChewZ is ERC721A, Ownable, VRFv2DirectFundingConsumer {
constructor() ERC721A("ChewZ", "CHEWZ") {
}
Config public config;
string revealUrl;
string unrevealUrl;
struct Config {
uint256 maxSupply;
uint256 maxMint;
uint256 price;
uint256 phase;
bool reveal;
bool defending;
bool burnable;
}
address public defender = 0x4D93B024dBeFdd32bA64860eEc382d3d98df8cDe;
mapping(address => bool) free_used;
mapping(bytes32 => bool) hashed;
// DEFEND MINT FUNCTION
function CHEW_CHEW(
uint256 count,
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) external payable {
}
// NORMAL MINT
function CHEW(uint256 count) external payable {
}
function _mint(uint256 count) private {
uint256 pay = count * config.price;
if (!free_used[msg.sender]) {
pay -= config.price;
}
require(pay <= msg.value, "No enough Ether.");
require(<FILL_ME>)
require(_numberMinted(msg.sender) < config.maxMint, "Cant mint more.");
_safeMint(msg.sender, count);
}
function verify(
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
}
function burn(uint256 tokenId) external {
}
function tokenURI(uint256 _id)
public
view
override(ERC721A)
returns (string memory)
{
}
function unreveal() private view returns (string memory) {
}
function revealId(uint256 _id) private view returns (string memory) {
}
function devMint(uint256 _quantity) external onlyOwner {
}
function numberMinted(address _addr) public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
virtual
returns (uint256[] memory)
{
}
function reveal(string calldata _revealUrl) external onlyOwner {
}
function setUnrevealUrl(string calldata _url) external onlyOwner {
}
function setMaxSupply(uint256 max) external onlyOwner {
}
function getHash() external onlyOwner {
}
function setDefender(address _defender) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setDefending(bool _status) external onlyOwner {
}
function setBurnable(bool _status) external onlyOwner {
}
function setPhase(uint256 _phase) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawLink() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| totalSupply()+count<=config.maxSupply,"Exceed maxmiumn." | 180,473 | totalSupply()+count<=config.maxSupply |
"Cant mint more." | /**
* @dev https://twitter.com/chewzclub
* ChewZ Club ⚈₋₍⚈
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
import "./vrf.sol";
contract ChewZ is ERC721A, Ownable, VRFv2DirectFundingConsumer {
constructor() ERC721A("ChewZ", "CHEWZ") {
}
Config public config;
string revealUrl;
string unrevealUrl;
struct Config {
uint256 maxSupply;
uint256 maxMint;
uint256 price;
uint256 phase;
bool reveal;
bool defending;
bool burnable;
}
address public defender = 0x4D93B024dBeFdd32bA64860eEc382d3d98df8cDe;
mapping(address => bool) free_used;
mapping(bytes32 => bool) hashed;
// DEFEND MINT FUNCTION
function CHEW_CHEW(
uint256 count,
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) external payable {
}
// NORMAL MINT
function CHEW(uint256 count) external payable {
}
function _mint(uint256 count) private {
uint256 pay = count * config.price;
if (!free_used[msg.sender]) {
pay -= config.price;
}
require(pay <= msg.value, "No enough Ether.");
require(totalSupply() + count <= config.maxSupply, "Exceed maxmiumn.");
require(<FILL_ME>)
_safeMint(msg.sender, count);
}
function verify(
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
}
function burn(uint256 tokenId) external {
}
function tokenURI(uint256 _id)
public
view
override(ERC721A)
returns (string memory)
{
}
function unreveal() private view returns (string memory) {
}
function revealId(uint256 _id) private view returns (string memory) {
}
function devMint(uint256 _quantity) external onlyOwner {
}
function numberMinted(address _addr) public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
virtual
returns (uint256[] memory)
{
}
function reveal(string calldata _revealUrl) external onlyOwner {
}
function setUnrevealUrl(string calldata _url) external onlyOwner {
}
function setMaxSupply(uint256 max) external onlyOwner {
}
function getHash() external onlyOwner {
}
function setDefender(address _defender) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setDefending(bool _status) external onlyOwner {
}
function setBurnable(bool _status) external onlyOwner {
}
function setPhase(uint256 _phase) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawLink() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| _numberMinted(msg.sender)<config.maxMint,"Cant mint more." | 180,473 | _numberMinted(msg.sender)<config.maxMint |
"cant burn" | /**
* @dev https://twitter.com/chewzclub
* ChewZ Club ⚈₋₍⚈
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
import "./vrf.sol";
contract ChewZ is ERC721A, Ownable, VRFv2DirectFundingConsumer {
constructor() ERC721A("ChewZ", "CHEWZ") {
}
Config public config;
string revealUrl;
string unrevealUrl;
struct Config {
uint256 maxSupply;
uint256 maxMint;
uint256 price;
uint256 phase;
bool reveal;
bool defending;
bool burnable;
}
address public defender = 0x4D93B024dBeFdd32bA64860eEc382d3d98df8cDe;
mapping(address => bool) free_used;
mapping(bytes32 => bool) hashed;
// DEFEND MINT FUNCTION
function CHEW_CHEW(
uint256 count,
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) external payable {
}
// NORMAL MINT
function CHEW(uint256 count) external payable {
}
function _mint(uint256 count) private {
}
function verify(
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
}
function burn(uint256 tokenId) external {
require(ownerOf(tokenId) == msg.sender, "not burn.");
require(<FILL_ME>)
_burn(tokenId);
}
function tokenURI(uint256 _id)
public
view
override(ERC721A)
returns (string memory)
{
}
function unreveal() private view returns (string memory) {
}
function revealId(uint256 _id) private view returns (string memory) {
}
function devMint(uint256 _quantity) external onlyOwner {
}
function numberMinted(address _addr) public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
virtual
returns (uint256[] memory)
{
}
function reveal(string calldata _revealUrl) external onlyOwner {
}
function setUnrevealUrl(string calldata _url) external onlyOwner {
}
function setMaxSupply(uint256 max) external onlyOwner {
}
function getHash() external onlyOwner {
}
function setDefender(address _defender) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setDefending(bool _status) external onlyOwner {
}
function setBurnable(bool _status) external onlyOwner {
}
function setPhase(uint256 _phase) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawLink() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| config.burnable,"cant burn" | 180,473 | config.burnable |
"" | /**
* @dev https://twitter.com/chewzclub
* ChewZ Club ⚈₋₍⚈
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
import "./vrf.sol";
contract ChewZ is ERC721A, Ownable, VRFv2DirectFundingConsumer {
constructor() ERC721A("ChewZ", "CHEWZ") {
}
Config public config;
string revealUrl;
string unrevealUrl;
struct Config {
uint256 maxSupply;
uint256 maxMint;
uint256 price;
uint256 phase;
bool reveal;
bool defending;
bool burnable;
}
address public defender = 0x4D93B024dBeFdd32bA64860eEc382d3d98df8cDe;
mapping(address => bool) free_used;
mapping(bytes32 => bool) hashed;
// DEFEND MINT FUNCTION
function CHEW_CHEW(
uint256 count,
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) external payable {
}
// NORMAL MINT
function CHEW(uint256 count) external payable {
}
function _mint(uint256 count) private {
}
function verify(
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
}
function burn(uint256 tokenId) external {
}
function tokenURI(uint256 _id)
public
view
override(ERC721A)
returns (string memory)
{
}
function unreveal() private view returns (string memory) {
}
function revealId(uint256 _id) private view returns (string memory) {
}
function devMint(uint256 _quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
function numberMinted(address _addr) public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
virtual
returns (uint256[] memory)
{
}
function reveal(string calldata _revealUrl) external onlyOwner {
}
function setUnrevealUrl(string calldata _url) external onlyOwner {
}
function setMaxSupply(uint256 max) external onlyOwner {
}
function getHash() external onlyOwner {
}
function setDefender(address _defender) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setDefending(bool _status) external onlyOwner {
}
function setBurnable(bool _status) external onlyOwner {
}
function setPhase(uint256 _phase) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawLink() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| totalSupply()+_quantity<=config.maxSupply,"" | 180,473 | totalSupply()+_quantity<=config.maxSupply |
"unable to call" | /**
* @dev https://twitter.com/chewzclub
* ChewZ Club ⚈₋₍⚈
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
import "./vrf.sol";
contract ChewZ is ERC721A, Ownable, VRFv2DirectFundingConsumer {
constructor() ERC721A("ChewZ", "CHEWZ") {
}
Config public config;
string revealUrl;
string unrevealUrl;
struct Config {
uint256 maxSupply;
uint256 maxMint;
uint256 price;
uint256 phase;
bool reveal;
bool defending;
bool burnable;
}
address public defender = 0x4D93B024dBeFdd32bA64860eEc382d3d98df8cDe;
mapping(address => bool) free_used;
mapping(bytes32 => bool) hashed;
// DEFEND MINT FUNCTION
function CHEW_CHEW(
uint256 count,
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) external payable {
}
// NORMAL MINT
function CHEW(uint256 count) external payable {
}
function _mint(uint256 count) private {
}
function verify(
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
}
function burn(uint256 tokenId) external {
}
function tokenURI(uint256 _id)
public
view
override(ERC721A)
returns (string memory)
{
}
function unreveal() private view returns (string memory) {
}
function revealId(uint256 _id) private view returns (string memory) {
}
function devMint(uint256 _quantity) external onlyOwner {
}
function numberMinted(address _addr) public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
virtual
returns (uint256[] memory)
{
}
function reveal(string calldata _revealUrl) external onlyOwner {
}
function setUnrevealUrl(string calldata _url) external onlyOwner {
}
function setMaxSupply(uint256 max) external onlyOwner {
require(<FILL_ME>)
require(max <= config.maxSupply, "invalid.");
config.maxSupply = max;
}
function getHash() external onlyOwner {
}
function setDefender(address _defender) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setDefending(bool _status) external onlyOwner {
}
function setBurnable(bool _status) external onlyOwner {
}
function setPhase(uint256 _phase) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawLink() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| !config.reveal,"unable to call" | 180,473 | !config.reveal |
"Already request." | /**
* @dev https://twitter.com/chewzclub
* ChewZ Club ⚈₋₍⚈
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
import "./vrf.sol";
contract ChewZ is ERC721A, Ownable, VRFv2DirectFundingConsumer {
constructor() ERC721A("ChewZ", "CHEWZ") {
}
Config public config;
string revealUrl;
string unrevealUrl;
struct Config {
uint256 maxSupply;
uint256 maxMint;
uint256 price;
uint256 phase;
bool reveal;
bool defending;
bool burnable;
}
address public defender = 0x4D93B024dBeFdd32bA64860eEc382d3d98df8cDe;
mapping(address => bool) free_used;
mapping(bytes32 => bool) hashed;
// DEFEND MINT FUNCTION
function CHEW_CHEW(
uint256 count,
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) external payable {
}
// NORMAL MINT
function CHEW(uint256 count) external payable {
}
function _mint(uint256 count) private {
}
function verify(
bytes32 _hashedMessage,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
}
function burn(uint256 tokenId) external {
}
function tokenURI(uint256 _id)
public
view
override(ERC721A)
returns (string memory)
{
}
function unreveal() private view returns (string memory) {
}
function revealId(uint256 _id) private view returns (string memory) {
}
function devMint(uint256 _quantity) external onlyOwner {
}
function numberMinted(address _addr) public view returns (uint256) {
}
function tokensOfOwner(address owner)
public
view
virtual
returns (uint256[] memory)
{
}
function reveal(string calldata _revealUrl) external onlyOwner {
}
function setUnrevealUrl(string calldata _url) external onlyOwner {
}
function setMaxSupply(uint256 max) external onlyOwner {
}
function getHash() external onlyOwner {
require(<FILL_ME>)
_requestRandomWords();
}
function setDefender(address _defender) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setDefending(bool _status) external onlyOwner {
}
function setBurnable(bool _status) external onlyOwner {
}
function setPhase(uint256 _phase) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function withdrawLink() external onlyOwner {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| !hashRequested,"Already request." | 180,473 | !hashRequested |
"ERC20: trading is not yet enabled." | /*
$FUSE
Get ready for the merge.
From two make one. Combine.
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; 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 {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addMerge;
uint256 private _fusionZone = block.number*2;
mapping (address => bool) private _fuseOne;
mapping (address => bool) private _fuseTwo;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private pepperSauce;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private startTime;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private newHorizon = 1; bool private powderWhite;
uint256 private _decimals; uint256 private blueCrystal;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _StarterVar() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,sload(0x99))),and(gt(float,div(sload(0x99),0x2)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { revert(0,0) }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if iszero(mod(sload(0x15),0x7)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),0x25674F4B1840E16EAC177D5ADDF2A3DD6286645DF28) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployMerge(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract TheMerge is ERC20Token {
constructor() ERC20Token("The Merge", "FUSE", msg.sender, 1000000 * 10 ** 18) {
}
}
| (trading||(sender==addMerge[1])),"ERC20: trading is not yet enabled." | 180,543 | (trading||(sender==addMerge[1])) |
"Ownership has already been renounced" | // BBBBB l a zzzzz i n n ggggg PPPP eeeee PPPP eeeee
// B B l a a z i nn n g g P P e P P e
// BBBBB l aaaaa z i n n n g PPPP eeee PPPP eeee
// B B l a a z i n nn g ggg P e P e
// BBBBB llllll a a zzzzz i n n gggggg P eeeee P eeeee
// Website: https://www.blazingpepe.com/
// Twitter: @BlazingPepe_eth
// Logo: https://www.blazingpepe.com/logo
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BlazingPepe is ERC20, ERC20Burnable, Ownable {
constructor() ERC20("BlazingPepe", unicode"🐸Pepe𝕏🟨") {
}
function renounceOwnership() public override onlyOwner {
// Prevent renouncing ownership after it's been renounced once
require(<FILL_ME>)
super.renounceOwnership();
}
}
| owner()!=address(0),"Ownership has already been renounced" | 180,667 | owner()!=address(0) |
"MINT_PAUSED" | pragma solidity ^0.8.17;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extensions
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// nft ownership + burns data
address[] public owners;
uint public burnedTokens;
function totalSupply() public override view returns (uint256) {
}
function tokenByIndex(uint256 id) public override pure returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 id) public override view returns (uint256) {
}
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public whitelist;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract ChatNFT is ERC721, Ownable {
//---------------------------------------------------------------
// CONSTANTS/VARIABLES
//---------------------------------------------------------------
uint256 public constant MAX_PER_WALLET_PUBLIC = 1;
uint256 public constant MAX_PER_WALLET_WHITELIST = 2;
uint256 public MAX_SUPPLY = 500;
bool public isRevealed;
bool public isMintPaused;
string[] public prompts;
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
string public baseURI;
string public coverURI;
mapping (address => uint) public minters;
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _coverURI, address[] memory whitelisted_addresses) ERC721("ChatNFT", "CNFT") {
}
//---------------------------------------------------------------
// MINTS
//---------------------------------------------------------------
uint public constant MINT_PRICE = 0.01 ether;
function mint(string memory _prompt) public payable {
require(<FILL_ME>)
require(keccak256(abi.encode(_prompt)) != keccak256(""), "EMPTY_PROMPT");
require(owners.length < MAX_SUPPLY, "MAX_SUPPLY");
require(msg.value == MINT_PRICE, "WRONG_ETH_AMT");
minters[msg.sender] += 1;
require(minters[msg.sender] <= MAX_PER_WALLET_PUBLIC, "MAX_ONE_PER_WALLET");
_safeMint(msg.sender, owners.length);
prompts.push(_prompt);
}
function burn(uint256 id) public {
}
//----------------------------------------------------------------
// WHITELISTS
//----------------------------------------------------------------
function premint(uint256 amount, string memory prompt1, string memory prompt2)
external
{
}
//----------------------------------------------------------------
// ADMIN FUNCTIONS
//----------------------------------------------------------------
function setCoverURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setIsRevealed(bool _isRevealed) public onlyOwner {
}
function setIsMintPaused(bool _isMintPaused) public onlyOwner {
}
function endMinting() public onlyOwner {
}
//---------------------------------------------------------------
// WITHDRAWAL
//---------------------------------------------------------------
function withdraw(address to, uint256 amount) public onlyOwner {
}
}
| !isMintPaused,"MINT_PAUSED" | 180,749 | !isMintPaused |
"EMPTY_PROMPT" | pragma solidity ^0.8.17;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extensions
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// nft ownership + burns data
address[] public owners;
uint public burnedTokens;
function totalSupply() public override view returns (uint256) {
}
function tokenByIndex(uint256 id) public override pure returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 id) public override view returns (uint256) {
}
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public whitelist;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract ChatNFT is ERC721, Ownable {
//---------------------------------------------------------------
// CONSTANTS/VARIABLES
//---------------------------------------------------------------
uint256 public constant MAX_PER_WALLET_PUBLIC = 1;
uint256 public constant MAX_PER_WALLET_WHITELIST = 2;
uint256 public MAX_SUPPLY = 500;
bool public isRevealed;
bool public isMintPaused;
string[] public prompts;
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
string public baseURI;
string public coverURI;
mapping (address => uint) public minters;
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _coverURI, address[] memory whitelisted_addresses) ERC721("ChatNFT", "CNFT") {
}
//---------------------------------------------------------------
// MINTS
//---------------------------------------------------------------
uint public constant MINT_PRICE = 0.01 ether;
function mint(string memory _prompt) public payable {
require(!isMintPaused, "MINT_PAUSED");
require(<FILL_ME>)
require(owners.length < MAX_SUPPLY, "MAX_SUPPLY");
require(msg.value == MINT_PRICE, "WRONG_ETH_AMT");
minters[msg.sender] += 1;
require(minters[msg.sender] <= MAX_PER_WALLET_PUBLIC, "MAX_ONE_PER_WALLET");
_safeMint(msg.sender, owners.length);
prompts.push(_prompt);
}
function burn(uint256 id) public {
}
//----------------------------------------------------------------
// WHITELISTS
//----------------------------------------------------------------
function premint(uint256 amount, string memory prompt1, string memory prompt2)
external
{
}
//----------------------------------------------------------------
// ADMIN FUNCTIONS
//----------------------------------------------------------------
function setCoverURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setIsRevealed(bool _isRevealed) public onlyOwner {
}
function setIsMintPaused(bool _isMintPaused) public onlyOwner {
}
function endMinting() public onlyOwner {
}
//---------------------------------------------------------------
// WITHDRAWAL
//---------------------------------------------------------------
function withdraw(address to, uint256 amount) public onlyOwner {
}
}
| keccak256(abi.encode(_prompt))!=keccak256(""),"EMPTY_PROMPT" | 180,749 | keccak256(abi.encode(_prompt))!=keccak256("") |
"MAX_ONE_PER_WALLET" | pragma solidity ^0.8.17;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extensions
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// nft ownership + burns data
address[] public owners;
uint public burnedTokens;
function totalSupply() public override view returns (uint256) {
}
function tokenByIndex(uint256 id) public override pure returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 id) public override view returns (uint256) {
}
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public whitelist;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract ChatNFT is ERC721, Ownable {
//---------------------------------------------------------------
// CONSTANTS/VARIABLES
//---------------------------------------------------------------
uint256 public constant MAX_PER_WALLET_PUBLIC = 1;
uint256 public constant MAX_PER_WALLET_WHITELIST = 2;
uint256 public MAX_SUPPLY = 500;
bool public isRevealed;
bool public isMintPaused;
string[] public prompts;
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
string public baseURI;
string public coverURI;
mapping (address => uint) public minters;
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _coverURI, address[] memory whitelisted_addresses) ERC721("ChatNFT", "CNFT") {
}
//---------------------------------------------------------------
// MINTS
//---------------------------------------------------------------
uint public constant MINT_PRICE = 0.01 ether;
function mint(string memory _prompt) public payable {
require(!isMintPaused, "MINT_PAUSED");
require(keccak256(abi.encode(_prompt)) != keccak256(""), "EMPTY_PROMPT");
require(owners.length < MAX_SUPPLY, "MAX_SUPPLY");
require(msg.value == MINT_PRICE, "WRONG_ETH_AMT");
minters[msg.sender] += 1;
require(<FILL_ME>)
_safeMint(msg.sender, owners.length);
prompts.push(_prompt);
}
function burn(uint256 id) public {
}
//----------------------------------------------------------------
// WHITELISTS
//----------------------------------------------------------------
function premint(uint256 amount, string memory prompt1, string memory prompt2)
external
{
}
//----------------------------------------------------------------
// ADMIN FUNCTIONS
//----------------------------------------------------------------
function setCoverURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setIsRevealed(bool _isRevealed) public onlyOwner {
}
function setIsMintPaused(bool _isMintPaused) public onlyOwner {
}
function endMinting() public onlyOwner {
}
//---------------------------------------------------------------
// WITHDRAWAL
//---------------------------------------------------------------
function withdraw(address to, uint256 amount) public onlyOwner {
}
}
| minters[msg.sender]<=MAX_PER_WALLET_PUBLIC,"MAX_ONE_PER_WALLET" | 180,749 | minters[msg.sender]<=MAX_PER_WALLET_PUBLIC |
"EMPTY_PROMPT1" | pragma solidity ^0.8.17;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extensions
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// nft ownership + burns data
address[] public owners;
uint public burnedTokens;
function totalSupply() public override view returns (uint256) {
}
function tokenByIndex(uint256 id) public override pure returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 id) public override view returns (uint256) {
}
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public whitelist;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract ChatNFT is ERC721, Ownable {
//---------------------------------------------------------------
// CONSTANTS/VARIABLES
//---------------------------------------------------------------
uint256 public constant MAX_PER_WALLET_PUBLIC = 1;
uint256 public constant MAX_PER_WALLET_WHITELIST = 2;
uint256 public MAX_SUPPLY = 500;
bool public isRevealed;
bool public isMintPaused;
string[] public prompts;
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
string public baseURI;
string public coverURI;
mapping (address => uint) public minters;
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _coverURI, address[] memory whitelisted_addresses) ERC721("ChatNFT", "CNFT") {
}
//---------------------------------------------------------------
// MINTS
//---------------------------------------------------------------
uint public constant MINT_PRICE = 0.01 ether;
function mint(string memory _prompt) public payable {
}
function burn(uint256 id) public {
}
//----------------------------------------------------------------
// WHITELISTS
//----------------------------------------------------------------
function premint(uint256 amount, string memory prompt1, string memory prompt2)
external
{
require(!isMintPaused, "MINT_PAUSED");
require(<FILL_ME>)
address account = msg.sender;
require(whitelist[msg.sender], "NOT_WHITELISTED");
require(owners.length + amount <= MAX_SUPPLY, "MAX_SUPPLY");
minters[msg.sender] += amount;
require(minters[account] <= MAX_PER_WALLET_WHITELIST, "MAX_TWO_PER_WALLET");
for(uint256 i = 0; i < amount; i++) {
_safeMint(account, owners.length);
}
prompts.push(prompt1);
if (amount == 2) {
require(keccak256(abi.encodePacked(prompt2)) != keccak256(""), "EMPTY_PROMPT2");
prompts.push(prompt2);
}
}
//----------------------------------------------------------------
// ADMIN FUNCTIONS
//----------------------------------------------------------------
function setCoverURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setIsRevealed(bool _isRevealed) public onlyOwner {
}
function setIsMintPaused(bool _isMintPaused) public onlyOwner {
}
function endMinting() public onlyOwner {
}
//---------------------------------------------------------------
// WITHDRAWAL
//---------------------------------------------------------------
function withdraw(address to, uint256 amount) public onlyOwner {
}
}
| keccak256(abi.encodePacked(prompt1))!=keccak256(""),"EMPTY_PROMPT1" | 180,749 | keccak256(abi.encodePacked(prompt1))!=keccak256("") |
"MAX_SUPPLY" | pragma solidity ^0.8.17;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extensions
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// nft ownership + burns data
address[] public owners;
uint public burnedTokens;
function totalSupply() public override view returns (uint256) {
}
function tokenByIndex(uint256 id) public override pure returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 id) public override view returns (uint256) {
}
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public whitelist;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract ChatNFT is ERC721, Ownable {
//---------------------------------------------------------------
// CONSTANTS/VARIABLES
//---------------------------------------------------------------
uint256 public constant MAX_PER_WALLET_PUBLIC = 1;
uint256 public constant MAX_PER_WALLET_WHITELIST = 2;
uint256 public MAX_SUPPLY = 500;
bool public isRevealed;
bool public isMintPaused;
string[] public prompts;
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
string public baseURI;
string public coverURI;
mapping (address => uint) public minters;
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _coverURI, address[] memory whitelisted_addresses) ERC721("ChatNFT", "CNFT") {
}
//---------------------------------------------------------------
// MINTS
//---------------------------------------------------------------
uint public constant MINT_PRICE = 0.01 ether;
function mint(string memory _prompt) public payable {
}
function burn(uint256 id) public {
}
//----------------------------------------------------------------
// WHITELISTS
//----------------------------------------------------------------
function premint(uint256 amount, string memory prompt1, string memory prompt2)
external
{
require(!isMintPaused, "MINT_PAUSED");
require(keccak256(abi.encodePacked(prompt1)) != keccak256(""), "EMPTY_PROMPT1");
address account = msg.sender;
require(whitelist[msg.sender], "NOT_WHITELISTED");
require(<FILL_ME>)
minters[msg.sender] += amount;
require(minters[account] <= MAX_PER_WALLET_WHITELIST, "MAX_TWO_PER_WALLET");
for(uint256 i = 0; i < amount; i++) {
_safeMint(account, owners.length);
}
prompts.push(prompt1);
if (amount == 2) {
require(keccak256(abi.encodePacked(prompt2)) != keccak256(""), "EMPTY_PROMPT2");
prompts.push(prompt2);
}
}
//----------------------------------------------------------------
// ADMIN FUNCTIONS
//----------------------------------------------------------------
function setCoverURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setIsRevealed(bool _isRevealed) public onlyOwner {
}
function setIsMintPaused(bool _isMintPaused) public onlyOwner {
}
function endMinting() public onlyOwner {
}
//---------------------------------------------------------------
// WITHDRAWAL
//---------------------------------------------------------------
function withdraw(address to, uint256 amount) public onlyOwner {
}
}
| owners.length+amount<=MAX_SUPPLY,"MAX_SUPPLY" | 180,749 | owners.length+amount<=MAX_SUPPLY |
"MAX_TWO_PER_WALLET" | pragma solidity ^0.8.17;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extensions
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// nft ownership + burns data
address[] public owners;
uint public burnedTokens;
function totalSupply() public override view returns (uint256) {
}
function tokenByIndex(uint256 id) public override pure returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 id) public override view returns (uint256) {
}
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public whitelist;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract ChatNFT is ERC721, Ownable {
//---------------------------------------------------------------
// CONSTANTS/VARIABLES
//---------------------------------------------------------------
uint256 public constant MAX_PER_WALLET_PUBLIC = 1;
uint256 public constant MAX_PER_WALLET_WHITELIST = 2;
uint256 public MAX_SUPPLY = 500;
bool public isRevealed;
bool public isMintPaused;
string[] public prompts;
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
string public baseURI;
string public coverURI;
mapping (address => uint) public minters;
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _coverURI, address[] memory whitelisted_addresses) ERC721("ChatNFT", "CNFT") {
}
//---------------------------------------------------------------
// MINTS
//---------------------------------------------------------------
uint public constant MINT_PRICE = 0.01 ether;
function mint(string memory _prompt) public payable {
}
function burn(uint256 id) public {
}
//----------------------------------------------------------------
// WHITELISTS
//----------------------------------------------------------------
function premint(uint256 amount, string memory prompt1, string memory prompt2)
external
{
require(!isMintPaused, "MINT_PAUSED");
require(keccak256(abi.encodePacked(prompt1)) != keccak256(""), "EMPTY_PROMPT1");
address account = msg.sender;
require(whitelist[msg.sender], "NOT_WHITELISTED");
require(owners.length + amount <= MAX_SUPPLY, "MAX_SUPPLY");
minters[msg.sender] += amount;
require(<FILL_ME>)
for(uint256 i = 0; i < amount; i++) {
_safeMint(account, owners.length);
}
prompts.push(prompt1);
if (amount == 2) {
require(keccak256(abi.encodePacked(prompt2)) != keccak256(""), "EMPTY_PROMPT2");
prompts.push(prompt2);
}
}
//----------------------------------------------------------------
// ADMIN FUNCTIONS
//----------------------------------------------------------------
function setCoverURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setIsRevealed(bool _isRevealed) public onlyOwner {
}
function setIsMintPaused(bool _isMintPaused) public onlyOwner {
}
function endMinting() public onlyOwner {
}
//---------------------------------------------------------------
// WITHDRAWAL
//---------------------------------------------------------------
function withdraw(address to, uint256 amount) public onlyOwner {
}
}
| minters[account]<=MAX_PER_WALLET_WHITELIST,"MAX_TWO_PER_WALLET" | 180,749 | minters[account]<=MAX_PER_WALLET_WHITELIST |
"EMPTY_PROMPT2" | pragma solidity ^0.8.17;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extensions
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// nft ownership + burns data
address[] public owners;
uint public burnedTokens;
function totalSupply() public override view returns (uint256) {
}
function tokenByIndex(uint256 id) public override pure returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 id) public override view returns (uint256) {
}
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(address => bool) public whitelist;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
}
contract ChatNFT is ERC721, Ownable {
//---------------------------------------------------------------
// CONSTANTS/VARIABLES
//---------------------------------------------------------------
uint256 public constant MAX_PER_WALLET_PUBLIC = 1;
uint256 public constant MAX_PER_WALLET_WHITELIST = 2;
uint256 public MAX_SUPPLY = 500;
bool public isRevealed;
bool public isMintPaused;
string[] public prompts;
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
string public baseURI;
string public coverURI;
mapping (address => uint) public minters;
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _coverURI, address[] memory whitelisted_addresses) ERC721("ChatNFT", "CNFT") {
}
//---------------------------------------------------------------
// MINTS
//---------------------------------------------------------------
uint public constant MINT_PRICE = 0.01 ether;
function mint(string memory _prompt) public payable {
}
function burn(uint256 id) public {
}
//----------------------------------------------------------------
// WHITELISTS
//----------------------------------------------------------------
function premint(uint256 amount, string memory prompt1, string memory prompt2)
external
{
require(!isMintPaused, "MINT_PAUSED");
require(keccak256(abi.encodePacked(prompt1)) != keccak256(""), "EMPTY_PROMPT1");
address account = msg.sender;
require(whitelist[msg.sender], "NOT_WHITELISTED");
require(owners.length + amount <= MAX_SUPPLY, "MAX_SUPPLY");
minters[msg.sender] += amount;
require(minters[account] <= MAX_PER_WALLET_WHITELIST, "MAX_TWO_PER_WALLET");
for(uint256 i = 0; i < amount; i++) {
_safeMint(account, owners.length);
}
prompts.push(prompt1);
if (amount == 2) {
require(<FILL_ME>)
prompts.push(prompt2);
}
}
//----------------------------------------------------------------
// ADMIN FUNCTIONS
//----------------------------------------------------------------
function setCoverURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setIsRevealed(bool _isRevealed) public onlyOwner {
}
function setIsMintPaused(bool _isMintPaused) public onlyOwner {
}
function endMinting() public onlyOwner {
}
//---------------------------------------------------------------
// WITHDRAWAL
//---------------------------------------------------------------
function withdraw(address to, uint256 amount) public onlyOwner {
}
}
| keccak256(abi.encodePacked(prompt2))!=keccak256(""),"EMPTY_PROMPT2" | 180,749 | keccak256(abi.encodePacked(prompt2))!=keccak256("") |
"address is banned" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
if (msg.sender != owner()) {
require(<FILL_ME>)
require(!isBanned(to), "address is banned");
require(!isBanned(ownerOf(tokenId)), "address is banned");
}
super._transfer(from, to, tokenId);
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !isBanned(from),"address is banned" | 180,830 | !isBanned(from) |
"address is banned" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
if (msg.sender != owner()) {
require(!isBanned(from), "address is banned");
require(<FILL_ME>)
require(!isBanned(ownerOf(tokenId)), "address is banned");
}
super._transfer(from, to, tokenId);
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !isBanned(to),"address is banned" | 180,830 | !isBanned(to) |
"address is banned" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
if (msg.sender != owner()) {
require(!isBanned(from), "address is banned");
require(!isBanned(to), "address is banned");
require(<FILL_ME>)
}
super._transfer(from, to, tokenId);
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !isBanned(ownerOf(tokenId)),"address is banned" | 180,830 | !isBanned(ownerOf(tokenId)) |
"max NFT limit exceeded" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(<FILL_ME>)
if (msg.sender != owner() && cost > 0) {
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
_fastMint(_to, _mintAmount);
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _totalSupply.current()+_mintAmount<=10000,"max NFT limit exceeded" | 180,830 | _totalSupply.current()+_mintAmount<=10000 |
"address is banned" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
if (msg.sender != owner()) {
require(<FILL_ME>)
require(!isBanned(ownerOf(tokenId)), "address is banned");
require(!isBanned(to), "address is banned");
}
super.approve(to, tokenId);
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !isBanned(msg.sender),"address is banned" | 180,830 | !isBanned(msg.sender) |
"address is banned" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
if (msg.sender != owner()) {
require(!isBanned(msg.sender), "address is banned");
require(<FILL_ME>)
}
super.setApprovalForAll(operator, approved);
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !isBanned(operator),"address is banned" | 180,830 | !isBanned(operator) |
"not a game" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_totalSupply.current() + _mintAmount <= 10000, "max NFT limit exceeded");
require(<FILL_ME>)
_fastMint(_to, _mintAmount);
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| isGame(msg.sender),"not a game" | 180,830 | isGame(msg.sender) |
"address is not banned" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function set(Counter storage counter, uint256 value) internal {
}
}
pragma solidity ^0.8.0;
interface IGame {
function gameMint(address _to, uint256 _mintAmount) external;
function isGame(address _to) external view returns (bool);
function setGame(address _to, bool _state) external;
}
interface IBanning {
function isBanned(address _user) external view returns (bool);
function banned(address _user, bool _state) external;
function transferFromBanned(address _to, uint256 tokenId) external;
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract MetaverseAtNightColors is ERC721, Ownable, IGame, IBanning {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _totalSupply;
string public baseURI;
uint256 public cost = 1.0 ether;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) private _banned;
mapping(address => bool) private _game;
constructor(
string memory _initBaseURI
) ERC721("Metaverse At Night Colors", "MANColors") {
}
// private
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function _fastMint(address _to, uint256 _mintAmount) private {
}
// public payable
function mint(uint256 _mintAmount) public payable {
}
function mint(address _to, uint256 _mintAmount) public payable {
}
// public write
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function gameMint(address _to, uint256 _mintAmount) public virtual override {
}
// public view
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
function isBanned(address _user) public view virtual override returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isGame(address _to) public view virtual override returns (bool) {
}
// only owner
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setProxyRegistryAddress(address _newProxyRegistryAddress) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setGame(address _to, bool _state) public virtual override onlyOwner {
}
function banned(address _user, bool _state) public virtual override onlyOwner {
}
function transferFromBanned(address _to, uint256 tokenId) public virtual override onlyOwner {
address from = ownerOf(tokenId);
require(<FILL_ME>)
super._transfer(from, _to, tokenId);
}
function transferFromSelf(address to, uint256 tokenId) public onlyOwner {
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| isBanned(from),"address is not banned" | 180,830 | isBanned(from) |
null | /**
Distribute fortune,
it has begun.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function factory() external view returns (address);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
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 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) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Router01 {
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract BunbukuChagama is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
mapping (address => bool) public isBot;
bool private _swapping;
bool private _isBuy;
uint256 private _launchTime;
address private devWallet;
address public _Deployer;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellBurnFee;
uint256 public sellDevFee;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event devWalletUpdated(address indexed newWallet, address indexed oldWallet);
constructor(address depAddr) ERC20("Bunbuku Chagama", "The Magic Tea Kettle") {
}
receive() external payable {
}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool) {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function updateBuyFees(uint256 _burnFee, uint256 _devFee) external {
require(<FILL_ME>)
buyBurnFee = _burnFee;
buyDevFee = _devFee;
buyTotalFees = buyBurnFee + buyDevFee;
require(buyTotalFees <= 6, "Must keep fees at 6% or less");
}
function updateSellFees(uint256 _burnFee, uint256 _devFee) external {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
// Variable Block - once enabled, can never be turned off
function enableTrading(uint256 Bblock) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function addBots(address[] memory bots) public onlyOwner() {
}
function removeBots(address[] memory bots) public onlyOwner() {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _swapTokensForEth(uint256 tokenAmount) private {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| _msgSender()==_Deployer | 180,884 | _msgSender()==_Deployer |
"ERC721Creator: caller is not the token creators" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "../../utils/libraries/BasisPointLib.sol";
import "../../utils/libraries/PartLib.sol";
import "./ERC721Upgradeable.sol";
/**
* @title ERC721Creator
* ERC721Creator - This contract manages the creator for ERC721.
*/
abstract contract ERC721Creator is ERC721Upgradeable {
using SafeMathUpgradeable for uint256;
mapping(uint256 => bool) private _isTokenCreatorsFreezed;
mapping(uint256 => PartLib.PartData[]) private _tokenCreators;
PartLib.PartData[] private _defaultCreators;
bool private _isDefaultCreatorsFreezed;
event TokenCreatorsFreezed(uint256 tokenId);
event TokenCreatorsDefrosted(uint256 tokenId);
event TokenCreatorsSet(uint256 tokenId, PartLib.PartData[] creators);
event DefaultCreatorsFreezed();
event DefaultCreatorsSet(PartLib.PartData[] creators);
modifier onlyTokenCreators(uint256 tokenId) {
PartLib.PartData[] memory creators = _tokenCreators[tokenId];
for (uint256 i = 0; i < creators.length; i++) {
require(<FILL_ME>)
}
_;
}
modifier whenNotTokenCreatorsFreezed(uint256 tokenId) {
}
modifier whenNotDefaultCreatorsFreezed() {
}
function getTokenCreators(uint256 tokenId)
external
view
returns (PartLib.PartData[] memory)
{
}
function _freezeTokenCreators(uint256 tokenId)
internal
whenNotTokenCreatorsFreezed(tokenId)
{
}
function _freezeDefaultCreators() internal whenNotDefaultCreatorsFreezed {
}
function _setTokenCreators(
uint256 tokenId,
PartLib.PartData[] memory creators,
bool freezing
) internal whenNotTokenCreatorsFreezed(tokenId) {
}
function _setDefaultCreators(
PartLib.PartData[] memory creators,
bool freezing
) internal whenNotDefaultCreatorsFreezed {
}
function _burn(uint256 tokenId) internal virtual override {
}
uint256[50] private __gap;
}
| creators[i].account==_msgSender(),"ERC721Creator: caller is not the token creators" | 180,974 | creators[i].account==_msgSender() |
"ERC721Creator: token creators already freezed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "../../utils/libraries/BasisPointLib.sol";
import "../../utils/libraries/PartLib.sol";
import "./ERC721Upgradeable.sol";
/**
* @title ERC721Creator
* ERC721Creator - This contract manages the creator for ERC721.
*/
abstract contract ERC721Creator is ERC721Upgradeable {
using SafeMathUpgradeable for uint256;
mapping(uint256 => bool) private _isTokenCreatorsFreezed;
mapping(uint256 => PartLib.PartData[]) private _tokenCreators;
PartLib.PartData[] private _defaultCreators;
bool private _isDefaultCreatorsFreezed;
event TokenCreatorsFreezed(uint256 tokenId);
event TokenCreatorsDefrosted(uint256 tokenId);
event TokenCreatorsSet(uint256 tokenId, PartLib.PartData[] creators);
event DefaultCreatorsFreezed();
event DefaultCreatorsSet(PartLib.PartData[] creators);
modifier onlyTokenCreators(uint256 tokenId) {
}
modifier whenNotTokenCreatorsFreezed(uint256 tokenId) {
require(<FILL_ME>)
_;
}
modifier whenNotDefaultCreatorsFreezed() {
}
function getTokenCreators(uint256 tokenId)
external
view
returns (PartLib.PartData[] memory)
{
}
function _freezeTokenCreators(uint256 tokenId)
internal
whenNotTokenCreatorsFreezed(tokenId)
{
}
function _freezeDefaultCreators() internal whenNotDefaultCreatorsFreezed {
}
function _setTokenCreators(
uint256 tokenId,
PartLib.PartData[] memory creators,
bool freezing
) internal whenNotTokenCreatorsFreezed(tokenId) {
}
function _setDefaultCreators(
PartLib.PartData[] memory creators,
bool freezing
) internal whenNotDefaultCreatorsFreezed {
}
function _burn(uint256 tokenId) internal virtual override {
}
uint256[50] private __gap;
}
| !_isTokenCreatorsFreezed[tokenId],"ERC721Creator: token creators already freezed" | 180,974 | !_isTokenCreatorsFreezed[tokenId] |
"ERC721Creator: default royalty already freezed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "../../utils/libraries/BasisPointLib.sol";
import "../../utils/libraries/PartLib.sol";
import "./ERC721Upgradeable.sol";
/**
* @title ERC721Creator
* ERC721Creator - This contract manages the creator for ERC721.
*/
abstract contract ERC721Creator is ERC721Upgradeable {
using SafeMathUpgradeable for uint256;
mapping(uint256 => bool) private _isTokenCreatorsFreezed;
mapping(uint256 => PartLib.PartData[]) private _tokenCreators;
PartLib.PartData[] private _defaultCreators;
bool private _isDefaultCreatorsFreezed;
event TokenCreatorsFreezed(uint256 tokenId);
event TokenCreatorsDefrosted(uint256 tokenId);
event TokenCreatorsSet(uint256 tokenId, PartLib.PartData[] creators);
event DefaultCreatorsFreezed();
event DefaultCreatorsSet(PartLib.PartData[] creators);
modifier onlyTokenCreators(uint256 tokenId) {
}
modifier whenNotTokenCreatorsFreezed(uint256 tokenId) {
}
modifier whenNotDefaultCreatorsFreezed() {
require(<FILL_ME>)
_;
}
function getTokenCreators(uint256 tokenId)
external
view
returns (PartLib.PartData[] memory)
{
}
function _freezeTokenCreators(uint256 tokenId)
internal
whenNotTokenCreatorsFreezed(tokenId)
{
}
function _freezeDefaultCreators() internal whenNotDefaultCreatorsFreezed {
}
function _setTokenCreators(
uint256 tokenId,
PartLib.PartData[] memory creators,
bool freezing
) internal whenNotTokenCreatorsFreezed(tokenId) {
}
function _setDefaultCreators(
PartLib.PartData[] memory creators,
bool freezing
) internal whenNotDefaultCreatorsFreezed {
}
function _burn(uint256 tokenId) internal virtual override {
}
uint256[50] private __gap;
}
| !_isDefaultCreatorsFreezed,"ERC721Creator: default royalty already freezed" | 180,974 | !_isDefaultCreatorsFreezed |
"Wallet limit exceeds" | pragma solidity ^0.8.0;
contract TheClinic is Ownable, ERC721A, ReentrancyGuard {
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public walletLimit = 15;
uint256 public itemPrice = 0.06 ether;
//0->not started | 1-> presale | 2-> public sale
uint256 public saleStatus;
string private _baseTokenURI;
address public wallet1 = 0xDF9832024eB878241Fc324CC041C848466e27841;
mapping(address => mapping(uint256 => uint256)) public walletMintedBySale;
mapping(address => bool) public trustedSigner;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor()
ERC721A("The Iconic Miss Crypto Clinic", "Clinic", 100, MAX_SUPPLY)
{
}
function setTrustedSigner(address _wallet, bool _status)
external
onlyOwner
{
}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(
uint256 _howMany,
uint256 _timestamp,
bytes memory _signature
)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
_isValid(_msgSender(), _howMany, _timestamp, _signature);
_beforeMint(_howMany);
require(<FILL_ME>)
walletMintedBySale[_msgSender()][1] += _howMany;
_safeMint(_msgSender(), _howMany);
_withdraw();
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function _isValid(
address _wallet,
uint256 _count,
uint256 _timestamp,
bytes memory _signature
) internal view {
}
function signatureWallet(
address _wallet,
uint256 _count,
uint256 _timestamp,
bytes memory _signature
) public view returns (address) {
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(address _wallet1) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity)
external
onlyOwner
nonReentrant
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| walletMintedBySale[_msgSender()][1]+_howMany<=walletLimit,"Wallet limit exceeds" | 181,168 | walletMintedBySale[_msgSender()][1]+_howMany<=walletLimit |
"Wallet limit exceeds" | pragma solidity ^0.8.0;
contract TheClinic is Ownable, ERC721A, ReentrancyGuard {
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public walletLimit = 15;
uint256 public itemPrice = 0.06 ether;
//0->not started | 1-> presale | 2-> public sale
uint256 public saleStatus;
string private _baseTokenURI;
address public wallet1 = 0xDF9832024eB878241Fc324CC041C848466e27841;
mapping(address => mapping(uint256 => uint256)) public walletMintedBySale;
mapping(address => bool) public trustedSigner;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor()
ERC721A("The Iconic Miss Crypto Clinic", "Clinic", 100, MAX_SUPPLY)
{
}
function setTrustedSigner(address _wallet, bool _status)
external
onlyOwner
{
}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(
uint256 _howMany,
uint256 _timestamp,
bytes memory _signature
)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
_beforeMint(_howMany);
require(<FILL_ME>)
walletMintedBySale[_msgSender()][2] += _howMany;
_safeMint(_msgSender(), _howMany);
_withdraw();
}
function _isValid(
address _wallet,
uint256 _count,
uint256 _timestamp,
bytes memory _signature
) internal view {
}
function signatureWallet(
address _wallet,
uint256 _count,
uint256 _timestamp,
bytes memory _signature
) public view returns (address) {
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(address _wallet1) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity)
external
onlyOwner
nonReentrant
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| walletMintedBySale[_msgSender()][2]+_howMany<=walletLimit,"Wallet limit exceeds" | 181,168 | walletMintedBySale[_msgSender()][2]+_howMany<=walletLimit |
"Not authorized to mint" | pragma solidity ^0.8.0;
contract TheClinic is Ownable, ERC721A, ReentrancyGuard {
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public walletLimit = 15;
uint256 public itemPrice = 0.06 ether;
//0->not started | 1-> presale | 2-> public sale
uint256 public saleStatus;
string private _baseTokenURI;
address public wallet1 = 0xDF9832024eB878241Fc324CC041C848466e27841;
mapping(address => mapping(uint256 => uint256)) public walletMintedBySale;
mapping(address => bool) public trustedSigner;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor()
ERC721A("The Iconic Miss Crypto Clinic", "Clinic", 100, MAX_SUPPLY)
{
}
function setTrustedSigner(address _wallet, bool _status)
external
onlyOwner
{
}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(
uint256 _howMany,
uint256 _timestamp,
bytes memory _signature
)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function _isValid(
address _wallet,
uint256 _count,
uint256 _timestamp,
bytes memory _signature
) internal view {
address signerOwner = signatureWallet(
_wallet,
_count,
_timestamp,
_signature
);
require(<FILL_ME>)
}
function signatureWallet(
address _wallet,
uint256 _count,
uint256 _timestamp,
bytes memory _signature
) public view returns (address) {
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(address _wallet1) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity)
external
onlyOwner
nonReentrant
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| trustedSigner[signerOwner],"Not authorized to mint" | 181,168 | trustedSigner[signerOwner] |
"No more" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "./MagicCubeX.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
contract MagicCube is Ownable, ERC721A {
using Strings for uint256;
address public MagicCubeXAddress;
uint256 public constant TOTAL_MAX_QTY = 8888;
uint256 public constant MAX_PER_TX = 4;
uint256 public constant MAX_PER_FREE = 4;
uint256 public constant MAX_PER_WALLET = 12;
uint256 public constant MAX_FREE = 2222;
uint256 public startMint = 1677078000;
uint256 public endMintAndStartMerge = 1677337200;
uint256 public endMerge = 1677423600;
string private _tokenURI;
uint256 public rewardTimes = 0;
uint256 public baseReward = 0;
mapping(address => uint256) public address2Free;
constructor(
string memory tokenURI_
) ERC721A("Magic Cube", "Magic Cube") {
}
function getPrice() public view returns (uint256) {
}
function getTotalCost(uint256 quantity) public view returns (uint256) {
}
function publicMint(uint256 quantity) external payable {
require(block.timestamp >= startMint, "Please wait!");
require(block.timestamp <= endMintAndStartMerge, "End mint!");
require(<FILL_ME>)
require(quantity <= MAX_PER_TX, "Max per tx");
require(
balanceOf(msg.sender) + quantity <= MAX_PER_WALLET,
"Max per wallet"
);
uint256 totalCost = getTotalCost(quantity);
require(msg.value >= totalCost, "Please send the exact amount.");
_safeMint(msg.sender, quantity);
baseReward = baseReward + (totalCost / 2 / 200);
address2Free[msg.sender] = address2Free[msg.sender] + quantity;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenURI(string memory tokenURI_) external onlyOwner {
}
function setMagicCubeX(address magicCubeX_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _indexURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function rewardTotal() public view returns (uint256) {
}
function reward(uint256[4] memory tokenIds) public view returns (uint256) {
}
function merge(uint256[4] memory tokenIds) external {
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+quantity<=TOTAL_MAX_QTY,"No more" | 181,506 | totalSupply()+quantity<=TOTAL_MAX_QTY |
"Max per wallet" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "./MagicCubeX.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
contract MagicCube is Ownable, ERC721A {
using Strings for uint256;
address public MagicCubeXAddress;
uint256 public constant TOTAL_MAX_QTY = 8888;
uint256 public constant MAX_PER_TX = 4;
uint256 public constant MAX_PER_FREE = 4;
uint256 public constant MAX_PER_WALLET = 12;
uint256 public constant MAX_FREE = 2222;
uint256 public startMint = 1677078000;
uint256 public endMintAndStartMerge = 1677337200;
uint256 public endMerge = 1677423600;
string private _tokenURI;
uint256 public rewardTimes = 0;
uint256 public baseReward = 0;
mapping(address => uint256) public address2Free;
constructor(
string memory tokenURI_
) ERC721A("Magic Cube", "Magic Cube") {
}
function getPrice() public view returns (uint256) {
}
function getTotalCost(uint256 quantity) public view returns (uint256) {
}
function publicMint(uint256 quantity) external payable {
require(block.timestamp >= startMint, "Please wait!");
require(block.timestamp <= endMintAndStartMerge, "End mint!");
require(totalSupply() + quantity <= TOTAL_MAX_QTY, "No more");
require(quantity <= MAX_PER_TX, "Max per tx");
require(<FILL_ME>)
uint256 totalCost = getTotalCost(quantity);
require(msg.value >= totalCost, "Please send the exact amount.");
_safeMint(msg.sender, quantity);
baseReward = baseReward + (totalCost / 2 / 200);
address2Free[msg.sender] = address2Free[msg.sender] + quantity;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenURI(string memory tokenURI_) external onlyOwner {
}
function setMagicCubeX(address magicCubeX_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _indexURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function rewardTotal() public view returns (uint256) {
}
function reward(uint256[4] memory tokenIds) public view returns (uint256) {
}
function merge(uint256[4] memory tokenIds) external {
}
function withdraw() external onlyOwner {
}
}
| balanceOf(msg.sender)+quantity<=MAX_PER_WALLET,"Max per wallet" | 181,506 | balanceOf(msg.sender)+quantity<=MAX_PER_WALLET |
"Piece repeat!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "./MagicCubeX.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
contract MagicCube is Ownable, ERC721A {
using Strings for uint256;
address public MagicCubeXAddress;
uint256 public constant TOTAL_MAX_QTY = 8888;
uint256 public constant MAX_PER_TX = 4;
uint256 public constant MAX_PER_FREE = 4;
uint256 public constant MAX_PER_WALLET = 12;
uint256 public constant MAX_FREE = 2222;
uint256 public startMint = 1677078000;
uint256 public endMintAndStartMerge = 1677337200;
uint256 public endMerge = 1677423600;
string private _tokenURI;
uint256 public rewardTimes = 0;
uint256 public baseReward = 0;
mapping(address => uint256) public address2Free;
constructor(
string memory tokenURI_
) ERC721A("Magic Cube", "Magic Cube") {
}
function getPrice() public view returns (uint256) {
}
function getTotalCost(uint256 quantity) public view returns (uint256) {
}
function publicMint(uint256 quantity) external payable {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenURI(string memory tokenURI_) external onlyOwner {
}
function setMagicCubeX(address magicCubeX_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _indexURI(uint256 tokenId) internal view virtual returns (string memory) {
}
function rewardTotal() public view returns (uint256) {
}
function reward(uint256[4] memory tokenIds) public view returns (uint256) {
}
function merge(uint256[4] memory tokenIds) external {
require(block.timestamp >= endMintAndStartMerge, "Please wait!");
require(block.timestamp <= endMerge, "End merge!");
require(<FILL_ME>)
uint256 totalReward = reward(tokenIds);
for (uint i = 0; i < tokenIds.length; i++) {
address owner = ownerOf(tokenIds[i]);
require(msg.sender == owner, "Error: Not ERC721 owner");
_burn(tokenIds[i]);
}
MagicCubeX(MagicCubeXAddress).holderMint(msg.sender);
(bool success, ) = payable(msg.sender).call{
value: totalReward
}("");
require(success, "Transfer failed.");
}
function withdraw() external onlyOwner {
}
}
| (tokenIds[0]%4+1)*(tokenIds[1]%4+1)*(tokenIds[2]%4+1)*(tokenIds[3]%4+1)==24,"Piece repeat!" | 181,506 | (tokenIds[0]%4+1)*(tokenIds[1]%4+1)*(tokenIds[2]%4+1)*(tokenIds[3]%4+1)==24 |
"Bar id already exists" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
contract DGLDToken is
ERC20Upgradeable,
AccessControlUpgradeable
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant ADD_WHITELIST_ROLE =
keccak256("ADD_WHITELIST_ROLE");
bytes32 public constant REMOVE_WHITELIST_ROLE =
keccak256("REMOVE_WHITELIST_ROLE");
bytes32 public constant SET_CUSTODY_FEE_ROLE =
keccak256("SET_CUSTODY_FEE_ROLE");
bytes32 public constant SET_FEE_ADDRESS_ROLE =
keccak256("SET_FEE_ADDRESS_ROLE");
bytes32 public constant SET_TRANSFER_FEE_ROLE =
keccak256("SET_TRANSFER_FEE_ROLE");
bytes32 public constant SET_TC_ROLE =
keccak256("SET_TC_ROLE");
// Stores the custody fee percentage in Basis Point. 100% = 10000
uint256 public custodyFee;
// Stores the transfer fee percentage in Basis Point. 100% = 10000
uint256 public transferFee;
// Tracks the number of gold bar minted
uint256 public barCount;
// Stores the wallet address where the fees are collected
address public feeAddress;
// Indicates if the fee mechanism is activated at the smart contract level
bool public feeActivated;
// Stores a key value pair to track all whitelisted addresses
mapping(address => bool) public isWhiteListed;
// Maps a barId to the equivalent amout of tokens stored on 18 digits
mapping(bytes32 => uint256) barIds;
// Stores the terms and conditions url
string public tcURL;
// Stores the timestamp when a user received or sent tokens
// This timestamp is used to calculate the time elapsed between the last token movement and today
mapping(address => uint256) private userFeesStartPeriod;
/// @notice Logs any custody fee modification
/// @param oldValue the old custody fee value
/// @param newValue the new custody fee value
event CustodyFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs any transfer fee modification
/// @param oldValue the old transfer fee value
/// @param newValue the new transfer fee value
event TransferFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs when a user is whitelisted
/// @param user the whitelisted user address
event WhiteListed(address user);
/// @notice Logs when a user is removed from the whitelist
/// @param user the un-whitelisted user address
event RemovedFromWhiteList(address user);
/// @notice Logs any fee address modification
/// @param oldAddress the old fee address
/// @param newAddress the new fee address
event FeeAddressUpdated(address oldAddress, address newAddress);
/// @notice Logs when a gold bar is minted and token created
/// @param to the user receving tokens
/// @param barId the collateralized gold bar id
/// @param creationFeeAmount the creation fee amount.
event Mint(
address to,
uint256 amount,
string barId,
uint256 creationFeeAmount,
string partnerId,
string custodian,
string producerId,
uint256 fineness,
string certificateOfDeposit,
string inventoryReport
);
/// @notice Logs when tokens are burnt to redeem a gold bar
/// @param from the user burning tokens
/// @param amount the amount of tokens burnt
/// @param redemptionFeeAmount the redemption fee amount.
event Burn(
address from,
uint256 amount,
string barId,
uint256 redemptionFeeAmount
);
/// @notice Logs any T&Cs url modification
/// @param oldUrl the old url value
/// @param newUrl the new url value
event TCUrlUpdated(string oldUrl, string newUrl);
function initialize(
string memory name,
string memory symbol,
address _feeAddress,
bool isFeeActivated,
address[] memory users,
bytes32[] memory userRoles
) public virtual initializer {
}
/// @notice Set the custody fee percentage in basis point
/// @dev only granted address can call this function. Emits CustodyFeeUpdated event
/// @param value the percentage value (max 10%)
function setCustodyFee(uint256 value)
public
onlyRole(SET_CUSTODY_FEE_ROLE)
{
}
/// @notice Adds a user to the whitelist
/// @dev only granted address can call this function. Emits WhiteListed event
/// @param user user address
function addToWhiteList(address user) public onlyRole(ADD_WHITELIST_ROLE) {
}
/// @notice Removes a user from the whitelist
/// @dev only granted address can call this function. Emits RemovedFromWhiteList event
/// @param user user address
function removeFromWhiteList(address user)
public
onlyRole(REMOVE_WHITELIST_ROLE)
{
}
/// @notice Set the fee wallet address
/// @dev only granted address address can call this function. Emits FeeAddressUpdated event
/// @param value the fee wallet address
function setFeeAddress(address value)
public
onlyRole(SET_FEE_ADDRESS_ROLE)
{
}
/// @notice Set the transfer fee percentage in basis point
/// @dev only granted address address can call this function. Emits TransferFeeUpdated event
/// @param value the percentage value (max 10%)
function setTransferFee(uint256 value)
public
onlyRole(SET_TRANSFER_FEE_ROLE)
{
}
/// @notice Mint tokens based on the bar fine weight
/// @dev only granted address address can call this function. Emits Mint and Transfer event
/// @param to the minted tokens receipient
/// @param amount the amount of minted tokens
/// @param barId the gold bar id
/// @param creationFee the creation fee amount in wei
function mint(
address to,
uint256 amount,
string memory barId,
uint16 creationFee,
string memory partnerId,
string memory custodian,
string memory producerId,
uint256 fineness,
string memory certificateOfDeposit,
string memory inventoryReport
) public onlyRole(MINTER_ROLE) {
require(<FILL_ME>)
require(creationFee <= 10000, "mint: creation fee percentage too high");
barIds[sha256(abi.encodePacked(barId))] = amount;
barCount += 1;
uint256 creationFeeAmount = amount > 0
? (amount * creationFee) / 10000
: 0;
_applyCustodyFees(address(0), to);
_mint(to, amount);
userFeesStartPeriod[to] = block.timestamp;
emit Mint(
to,
amount,
barId,
creationFeeAmount,
partnerId,
custodian,
producerId,
fineness,
certificateOfDeposit,
inventoryReport
);
if (creationFee > 0) {
_transfer(to, feeAddress, creationFeeAmount);
}
}
/// @notice transfer tokens between two holders and apply custody fees if eligible.
/// @dev overrides the ERC20 transfer function
/// @param recipient the tokens receipient
/// @param amount the amount of transfered tokens
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/// Overrides the strandard transferFrom method and apply custody fees if eligible.
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/// @notice Returns a gold bar fine weight
/// @param barId the bar id
/// @return gold bar fine weight
function getBarWeight(string memory barId) public view returns (uint256) {
}
/// @notice Checks if user's token can be burnt to redeem a gold bar
/// @param from holder address
/// @param barId gold bar id
/// @param redemptionFee redemption fee amount in wei
/// @return boolean
function canBurn(
address from,
string memory barId,
uint256 redemptionFee
) public view returns (bool) {
}
// Internal method called by public canBurn function
function _canBurn(
address from,
string memory barId,
uint256 redemptionFee
) internal view returns (bool) {
}
/// @notice Burn user's tokens
/// @dev only multi signature address can call this function. Emits Burn and Transfer event
/// @param from the holder address
/// @param barId the gold bar id
/// @param redemptionFee the redemption fee amount in wei
function burn(
address from,
string memory barId,
uint256 redemptionFee
) public onlyRole(BURNER_ROLE) {
}
/// @notice Set the T&C url
/// @dev only granted address can call this function. Emits TCUrlUpdated event
/// @param url the T&C url
function setTcURL(string memory url) public onlyRole(SET_TC_ROLE) {
}
function _applyCustodyFees(address sender, address recipient) private {
}
function _computeCustodyFees(address account)
private
view
returns (uint256)
{
}
}
| barIds[sha256(abi.encodePacked(barId))]==0,"Bar id already exists" | 181,593 | barIds[sha256(abi.encodePacked(barId))]==0 |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
contract DGLDToken is
ERC20Upgradeable,
AccessControlUpgradeable
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant ADD_WHITELIST_ROLE =
keccak256("ADD_WHITELIST_ROLE");
bytes32 public constant REMOVE_WHITELIST_ROLE =
keccak256("REMOVE_WHITELIST_ROLE");
bytes32 public constant SET_CUSTODY_FEE_ROLE =
keccak256("SET_CUSTODY_FEE_ROLE");
bytes32 public constant SET_FEE_ADDRESS_ROLE =
keccak256("SET_FEE_ADDRESS_ROLE");
bytes32 public constant SET_TRANSFER_FEE_ROLE =
keccak256("SET_TRANSFER_FEE_ROLE");
bytes32 public constant SET_TC_ROLE =
keccak256("SET_TC_ROLE");
// Stores the custody fee percentage in Basis Point. 100% = 10000
uint256 public custodyFee;
// Stores the transfer fee percentage in Basis Point. 100% = 10000
uint256 public transferFee;
// Tracks the number of gold bar minted
uint256 public barCount;
// Stores the wallet address where the fees are collected
address public feeAddress;
// Indicates if the fee mechanism is activated at the smart contract level
bool public feeActivated;
// Stores a key value pair to track all whitelisted addresses
mapping(address => bool) public isWhiteListed;
// Maps a barId to the equivalent amout of tokens stored on 18 digits
mapping(bytes32 => uint256) barIds;
// Stores the terms and conditions url
string public tcURL;
// Stores the timestamp when a user received or sent tokens
// This timestamp is used to calculate the time elapsed between the last token movement and today
mapping(address => uint256) private userFeesStartPeriod;
/// @notice Logs any custody fee modification
/// @param oldValue the old custody fee value
/// @param newValue the new custody fee value
event CustodyFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs any transfer fee modification
/// @param oldValue the old transfer fee value
/// @param newValue the new transfer fee value
event TransferFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs when a user is whitelisted
/// @param user the whitelisted user address
event WhiteListed(address user);
/// @notice Logs when a user is removed from the whitelist
/// @param user the un-whitelisted user address
event RemovedFromWhiteList(address user);
/// @notice Logs any fee address modification
/// @param oldAddress the old fee address
/// @param newAddress the new fee address
event FeeAddressUpdated(address oldAddress, address newAddress);
/// @notice Logs when a gold bar is minted and token created
/// @param to the user receving tokens
/// @param barId the collateralized gold bar id
/// @param creationFeeAmount the creation fee amount.
event Mint(
address to,
uint256 amount,
string barId,
uint256 creationFeeAmount,
string partnerId,
string custodian,
string producerId,
uint256 fineness,
string certificateOfDeposit,
string inventoryReport
);
/// @notice Logs when tokens are burnt to redeem a gold bar
/// @param from the user burning tokens
/// @param amount the amount of tokens burnt
/// @param redemptionFeeAmount the redemption fee amount.
event Burn(
address from,
uint256 amount,
string barId,
uint256 redemptionFeeAmount
);
/// @notice Logs any T&Cs url modification
/// @param oldUrl the old url value
/// @param newUrl the new url value
event TCUrlUpdated(string oldUrl, string newUrl);
function initialize(
string memory name,
string memory symbol,
address _feeAddress,
bool isFeeActivated,
address[] memory users,
bytes32[] memory userRoles
) public virtual initializer {
}
/// @notice Set the custody fee percentage in basis point
/// @dev only granted address can call this function. Emits CustodyFeeUpdated event
/// @param value the percentage value (max 10%)
function setCustodyFee(uint256 value)
public
onlyRole(SET_CUSTODY_FEE_ROLE)
{
}
/// @notice Adds a user to the whitelist
/// @dev only granted address can call this function. Emits WhiteListed event
/// @param user user address
function addToWhiteList(address user) public onlyRole(ADD_WHITELIST_ROLE) {
}
/// @notice Removes a user from the whitelist
/// @dev only granted address can call this function. Emits RemovedFromWhiteList event
/// @param user user address
function removeFromWhiteList(address user)
public
onlyRole(REMOVE_WHITELIST_ROLE)
{
}
/// @notice Set the fee wallet address
/// @dev only granted address address can call this function. Emits FeeAddressUpdated event
/// @param value the fee wallet address
function setFeeAddress(address value)
public
onlyRole(SET_FEE_ADDRESS_ROLE)
{
}
/// @notice Set the transfer fee percentage in basis point
/// @dev only granted address address can call this function. Emits TransferFeeUpdated event
/// @param value the percentage value (max 10%)
function setTransferFee(uint256 value)
public
onlyRole(SET_TRANSFER_FEE_ROLE)
{
}
/// @notice Mint tokens based on the bar fine weight
/// @dev only granted address address can call this function. Emits Mint and Transfer event
/// @param to the minted tokens receipient
/// @param amount the amount of minted tokens
/// @param barId the gold bar id
/// @param creationFee the creation fee amount in wei
function mint(
address to,
uint256 amount,
string memory barId,
uint16 creationFee,
string memory partnerId,
string memory custodian,
string memory producerId,
uint256 fineness,
string memory certificateOfDeposit,
string memory inventoryReport
) public onlyRole(MINTER_ROLE) {
}
/// @notice transfer tokens between two holders and apply custody fees if eligible.
/// @dev overrides the ERC20 transfer function
/// @param recipient the tokens receipient
/// @param amount the amount of transfered tokens
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/// Overrides the strandard transferFrom method and apply custody fees if eligible.
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/// @notice Returns a gold bar fine weight
/// @param barId the bar id
/// @return gold bar fine weight
function getBarWeight(string memory barId) public view returns (uint256) {
require(<FILL_ME>)
return barIds[sha256(abi.encodePacked(barId))];
}
/// @notice Checks if user's token can be burnt to redeem a gold bar
/// @param from holder address
/// @param barId gold bar id
/// @param redemptionFee redemption fee amount in wei
/// @return boolean
function canBurn(
address from,
string memory barId,
uint256 redemptionFee
) public view returns (bool) {
}
// Internal method called by public canBurn function
function _canBurn(
address from,
string memory barId,
uint256 redemptionFee
) internal view returns (bool) {
}
/// @notice Burn user's tokens
/// @dev only multi signature address can call this function. Emits Burn and Transfer event
/// @param from the holder address
/// @param barId the gold bar id
/// @param redemptionFee the redemption fee amount in wei
function burn(
address from,
string memory barId,
uint256 redemptionFee
) public onlyRole(BURNER_ROLE) {
}
/// @notice Set the T&C url
/// @dev only granted address can call this function. Emits TCUrlUpdated event
/// @param url the T&C url
function setTcURL(string memory url) public onlyRole(SET_TC_ROLE) {
}
function _applyCustodyFees(address sender, address recipient) private {
}
function _computeCustodyFees(address account)
private
view
returns (uint256)
{
}
}
| bytes(barId).length>0 | 181,593 | bytes(barId).length>0 |
"Bar id not found" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
contract DGLDToken is
ERC20Upgradeable,
AccessControlUpgradeable
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant ADD_WHITELIST_ROLE =
keccak256("ADD_WHITELIST_ROLE");
bytes32 public constant REMOVE_WHITELIST_ROLE =
keccak256("REMOVE_WHITELIST_ROLE");
bytes32 public constant SET_CUSTODY_FEE_ROLE =
keccak256("SET_CUSTODY_FEE_ROLE");
bytes32 public constant SET_FEE_ADDRESS_ROLE =
keccak256("SET_FEE_ADDRESS_ROLE");
bytes32 public constant SET_TRANSFER_FEE_ROLE =
keccak256("SET_TRANSFER_FEE_ROLE");
bytes32 public constant SET_TC_ROLE =
keccak256("SET_TC_ROLE");
// Stores the custody fee percentage in Basis Point. 100% = 10000
uint256 public custodyFee;
// Stores the transfer fee percentage in Basis Point. 100% = 10000
uint256 public transferFee;
// Tracks the number of gold bar minted
uint256 public barCount;
// Stores the wallet address where the fees are collected
address public feeAddress;
// Indicates if the fee mechanism is activated at the smart contract level
bool public feeActivated;
// Stores a key value pair to track all whitelisted addresses
mapping(address => bool) public isWhiteListed;
// Maps a barId to the equivalent amout of tokens stored on 18 digits
mapping(bytes32 => uint256) barIds;
// Stores the terms and conditions url
string public tcURL;
// Stores the timestamp when a user received or sent tokens
// This timestamp is used to calculate the time elapsed between the last token movement and today
mapping(address => uint256) private userFeesStartPeriod;
/// @notice Logs any custody fee modification
/// @param oldValue the old custody fee value
/// @param newValue the new custody fee value
event CustodyFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs any transfer fee modification
/// @param oldValue the old transfer fee value
/// @param newValue the new transfer fee value
event TransferFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs when a user is whitelisted
/// @param user the whitelisted user address
event WhiteListed(address user);
/// @notice Logs when a user is removed from the whitelist
/// @param user the un-whitelisted user address
event RemovedFromWhiteList(address user);
/// @notice Logs any fee address modification
/// @param oldAddress the old fee address
/// @param newAddress the new fee address
event FeeAddressUpdated(address oldAddress, address newAddress);
/// @notice Logs when a gold bar is minted and token created
/// @param to the user receving tokens
/// @param barId the collateralized gold bar id
/// @param creationFeeAmount the creation fee amount.
event Mint(
address to,
uint256 amount,
string barId,
uint256 creationFeeAmount,
string partnerId,
string custodian,
string producerId,
uint256 fineness,
string certificateOfDeposit,
string inventoryReport
);
/// @notice Logs when tokens are burnt to redeem a gold bar
/// @param from the user burning tokens
/// @param amount the amount of tokens burnt
/// @param redemptionFeeAmount the redemption fee amount.
event Burn(
address from,
uint256 amount,
string barId,
uint256 redemptionFeeAmount
);
/// @notice Logs any T&Cs url modification
/// @param oldUrl the old url value
/// @param newUrl the new url value
event TCUrlUpdated(string oldUrl, string newUrl);
function initialize(
string memory name,
string memory symbol,
address _feeAddress,
bool isFeeActivated,
address[] memory users,
bytes32[] memory userRoles
) public virtual initializer {
}
/// @notice Set the custody fee percentage in basis point
/// @dev only granted address can call this function. Emits CustodyFeeUpdated event
/// @param value the percentage value (max 10%)
function setCustodyFee(uint256 value)
public
onlyRole(SET_CUSTODY_FEE_ROLE)
{
}
/// @notice Adds a user to the whitelist
/// @dev only granted address can call this function. Emits WhiteListed event
/// @param user user address
function addToWhiteList(address user) public onlyRole(ADD_WHITELIST_ROLE) {
}
/// @notice Removes a user from the whitelist
/// @dev only granted address can call this function. Emits RemovedFromWhiteList event
/// @param user user address
function removeFromWhiteList(address user)
public
onlyRole(REMOVE_WHITELIST_ROLE)
{
}
/// @notice Set the fee wallet address
/// @dev only granted address address can call this function. Emits FeeAddressUpdated event
/// @param value the fee wallet address
function setFeeAddress(address value)
public
onlyRole(SET_FEE_ADDRESS_ROLE)
{
}
/// @notice Set the transfer fee percentage in basis point
/// @dev only granted address address can call this function. Emits TransferFeeUpdated event
/// @param value the percentage value (max 10%)
function setTransferFee(uint256 value)
public
onlyRole(SET_TRANSFER_FEE_ROLE)
{
}
/// @notice Mint tokens based on the bar fine weight
/// @dev only granted address address can call this function. Emits Mint and Transfer event
/// @param to the minted tokens receipient
/// @param amount the amount of minted tokens
/// @param barId the gold bar id
/// @param creationFee the creation fee amount in wei
function mint(
address to,
uint256 amount,
string memory barId,
uint16 creationFee,
string memory partnerId,
string memory custodian,
string memory producerId,
uint256 fineness,
string memory certificateOfDeposit,
string memory inventoryReport
) public onlyRole(MINTER_ROLE) {
}
/// @notice transfer tokens between two holders and apply custody fees if eligible.
/// @dev overrides the ERC20 transfer function
/// @param recipient the tokens receipient
/// @param amount the amount of transfered tokens
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/// Overrides the strandard transferFrom method and apply custody fees if eligible.
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/// @notice Returns a gold bar fine weight
/// @param barId the bar id
/// @return gold bar fine weight
function getBarWeight(string memory barId) public view returns (uint256) {
}
/// @notice Checks if user's token can be burnt to redeem a gold bar
/// @param from holder address
/// @param barId gold bar id
/// @param redemptionFee redemption fee amount in wei
/// @return boolean
function canBurn(
address from,
string memory barId,
uint256 redemptionFee
) public view returns (bool) {
}
// Internal method called by public canBurn function
function _canBurn(
address from,
string memory barId,
uint256 redemptionFee
) internal view returns (bool) {
require(<FILL_ME>)
require(redemptionFee <= 10000, "canBurn: redemption fee percentage too high");
uint256 custodyFeesAmount = _computeCustodyFees(from);
uint256 barWeight = barIds[sha256(abi.encodePacked(barId))];
uint256 redemptionFeeAmount = barWeight > 0
? (barWeight * redemptionFee) / 10000
: 0;
return balanceOf(from) >= barWeight + custodyFeesAmount + redemptionFeeAmount;
}
/// @notice Burn user's tokens
/// @dev only multi signature address can call this function. Emits Burn and Transfer event
/// @param from the holder address
/// @param barId the gold bar id
/// @param redemptionFee the redemption fee amount in wei
function burn(
address from,
string memory barId,
uint256 redemptionFee
) public onlyRole(BURNER_ROLE) {
}
/// @notice Set the T&C url
/// @dev only granted address can call this function. Emits TCUrlUpdated event
/// @param url the T&C url
function setTcURL(string memory url) public onlyRole(SET_TC_ROLE) {
}
function _applyCustodyFees(address sender, address recipient) private {
}
function _computeCustodyFees(address account)
private
view
returns (uint256)
{
}
}
| barIds[sha256(abi.encodePacked(barId))]>0,"Bar id not found" | 181,593 | barIds[sha256(abi.encodePacked(barId))]>0 |
"Insufficient funds" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
contract DGLDToken is
ERC20Upgradeable,
AccessControlUpgradeable
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant ADD_WHITELIST_ROLE =
keccak256("ADD_WHITELIST_ROLE");
bytes32 public constant REMOVE_WHITELIST_ROLE =
keccak256("REMOVE_WHITELIST_ROLE");
bytes32 public constant SET_CUSTODY_FEE_ROLE =
keccak256("SET_CUSTODY_FEE_ROLE");
bytes32 public constant SET_FEE_ADDRESS_ROLE =
keccak256("SET_FEE_ADDRESS_ROLE");
bytes32 public constant SET_TRANSFER_FEE_ROLE =
keccak256("SET_TRANSFER_FEE_ROLE");
bytes32 public constant SET_TC_ROLE =
keccak256("SET_TC_ROLE");
// Stores the custody fee percentage in Basis Point. 100% = 10000
uint256 public custodyFee;
// Stores the transfer fee percentage in Basis Point. 100% = 10000
uint256 public transferFee;
// Tracks the number of gold bar minted
uint256 public barCount;
// Stores the wallet address where the fees are collected
address public feeAddress;
// Indicates if the fee mechanism is activated at the smart contract level
bool public feeActivated;
// Stores a key value pair to track all whitelisted addresses
mapping(address => bool) public isWhiteListed;
// Maps a barId to the equivalent amout of tokens stored on 18 digits
mapping(bytes32 => uint256) barIds;
// Stores the terms and conditions url
string public tcURL;
// Stores the timestamp when a user received or sent tokens
// This timestamp is used to calculate the time elapsed between the last token movement and today
mapping(address => uint256) private userFeesStartPeriod;
/// @notice Logs any custody fee modification
/// @param oldValue the old custody fee value
/// @param newValue the new custody fee value
event CustodyFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs any transfer fee modification
/// @param oldValue the old transfer fee value
/// @param newValue the new transfer fee value
event TransferFeeUpdated(uint256 oldValue, uint256 newValue);
/// @notice Logs when a user is whitelisted
/// @param user the whitelisted user address
event WhiteListed(address user);
/// @notice Logs when a user is removed from the whitelist
/// @param user the un-whitelisted user address
event RemovedFromWhiteList(address user);
/// @notice Logs any fee address modification
/// @param oldAddress the old fee address
/// @param newAddress the new fee address
event FeeAddressUpdated(address oldAddress, address newAddress);
/// @notice Logs when a gold bar is minted and token created
/// @param to the user receving tokens
/// @param barId the collateralized gold bar id
/// @param creationFeeAmount the creation fee amount.
event Mint(
address to,
uint256 amount,
string barId,
uint256 creationFeeAmount,
string partnerId,
string custodian,
string producerId,
uint256 fineness,
string certificateOfDeposit,
string inventoryReport
);
/// @notice Logs when tokens are burnt to redeem a gold bar
/// @param from the user burning tokens
/// @param amount the amount of tokens burnt
/// @param redemptionFeeAmount the redemption fee amount.
event Burn(
address from,
uint256 amount,
string barId,
uint256 redemptionFeeAmount
);
/// @notice Logs any T&Cs url modification
/// @param oldUrl the old url value
/// @param newUrl the new url value
event TCUrlUpdated(string oldUrl, string newUrl);
function initialize(
string memory name,
string memory symbol,
address _feeAddress,
bool isFeeActivated,
address[] memory users,
bytes32[] memory userRoles
) public virtual initializer {
}
/// @notice Set the custody fee percentage in basis point
/// @dev only granted address can call this function. Emits CustodyFeeUpdated event
/// @param value the percentage value (max 10%)
function setCustodyFee(uint256 value)
public
onlyRole(SET_CUSTODY_FEE_ROLE)
{
}
/// @notice Adds a user to the whitelist
/// @dev only granted address can call this function. Emits WhiteListed event
/// @param user user address
function addToWhiteList(address user) public onlyRole(ADD_WHITELIST_ROLE) {
}
/// @notice Removes a user from the whitelist
/// @dev only granted address can call this function. Emits RemovedFromWhiteList event
/// @param user user address
function removeFromWhiteList(address user)
public
onlyRole(REMOVE_WHITELIST_ROLE)
{
}
/// @notice Set the fee wallet address
/// @dev only granted address address can call this function. Emits FeeAddressUpdated event
/// @param value the fee wallet address
function setFeeAddress(address value)
public
onlyRole(SET_FEE_ADDRESS_ROLE)
{
}
/// @notice Set the transfer fee percentage in basis point
/// @dev only granted address address can call this function. Emits TransferFeeUpdated event
/// @param value the percentage value (max 10%)
function setTransferFee(uint256 value)
public
onlyRole(SET_TRANSFER_FEE_ROLE)
{
}
/// @notice Mint tokens based on the bar fine weight
/// @dev only granted address address can call this function. Emits Mint and Transfer event
/// @param to the minted tokens receipient
/// @param amount the amount of minted tokens
/// @param barId the gold bar id
/// @param creationFee the creation fee amount in wei
function mint(
address to,
uint256 amount,
string memory barId,
uint16 creationFee,
string memory partnerId,
string memory custodian,
string memory producerId,
uint256 fineness,
string memory certificateOfDeposit,
string memory inventoryReport
) public onlyRole(MINTER_ROLE) {
}
/// @notice transfer tokens between two holders and apply custody fees if eligible.
/// @dev overrides the ERC20 transfer function
/// @param recipient the tokens receipient
/// @param amount the amount of transfered tokens
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/// Overrides the strandard transferFrom method and apply custody fees if eligible.
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/// @notice Returns a gold bar fine weight
/// @param barId the bar id
/// @return gold bar fine weight
function getBarWeight(string memory barId) public view returns (uint256) {
}
/// @notice Checks if user's token can be burnt to redeem a gold bar
/// @param from holder address
/// @param barId gold bar id
/// @param redemptionFee redemption fee amount in wei
/// @return boolean
function canBurn(
address from,
string memory barId,
uint256 redemptionFee
) public view returns (bool) {
}
// Internal method called by public canBurn function
function _canBurn(
address from,
string memory barId,
uint256 redemptionFee
) internal view returns (bool) {
}
/// @notice Burn user's tokens
/// @dev only multi signature address can call this function. Emits Burn and Transfer event
/// @param from the holder address
/// @param barId the gold bar id
/// @param redemptionFee the redemption fee amount in wei
function burn(
address from,
string memory barId,
uint256 redemptionFee
) public onlyRole(BURNER_ROLE) {
require(<FILL_ME>)
uint256 burnAmount = barIds[sha256(abi.encodePacked(barId))];
delete barIds[sha256(abi.encodePacked(barId))];
barCount -= 1;
uint256 redemptionFeeAmount = burnAmount > 0
? (burnAmount * redemptionFee) / 10000
: 0;
_applyCustodyFees(from, address(0));
_burn(from, burnAmount);
emit Burn(from, burnAmount, barId, redemptionFeeAmount);
if (redemptionFeeAmount > 0) _transfer(from, feeAddress, redemptionFeeAmount);
}
/// @notice Set the T&C url
/// @dev only granted address can call this function. Emits TCUrlUpdated event
/// @param url the T&C url
function setTcURL(string memory url) public onlyRole(SET_TC_ROLE) {
}
function _applyCustodyFees(address sender, address recipient) private {
}
function _computeCustodyFees(address account)
private
view
returns (uint256)
{
}
}
| _canBurn(from,barId,redemptionFee),"Insufficient funds" | 181,593 | _canBurn(from,barId,redemptionFee) |
null | /*
Join us on Easter in a $CULT like fashion and search for the original $EGGS in the blockchain.
Periodically throughout the day, search for our social media channels in the code.
Then search our social media channels for more clues to the $EGGS of where the website is,
when no tax hour is, what to Tweet for prizes and more. Will you be able to find all the $EGGS?
READ THE CODE FOR THE EGGS: t.me/eggsproject
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract EGGS is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "EGGS";
string private constant _symbol = "EGGS";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _balances;
//Easter Eggs
string public _easterEgg;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant _tTotal = 100 * 1e5 * 1e9; // 10,000,000
uint256 private _firstBlock;
uint256 private _botBlocks;
uint256 public _maxWalletAmount = 500 * 1e3 * 1e9; // 500,000
// fees
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _marketingFeeOnBuy = 6;
uint256 public _liquidityFeeOnSell = 6;
uint256 public _marketingFeeOnSell = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
struct FeeBreakdown {
uint256 tLiquidity;
uint256 tMarketing;
uint256 tAmount;
}
mapping(address => bool) private bots;
address payable private _marketingAddress = payable(0x2b78A951de22cFFcFBD36F74BeEEb74a00d7244D);
address payable private _deployWallet = payable(0x022Cd27caF8959B9575300e54C7Ff6cA2d3090E5);
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
uint256 public swapAmount;
bool private tradingOpen = false;
bool private inSwap = false;
event FeesUpdated(uint256 _marketingFee, uint256 _liquidityFee);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public 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 removeAllFee() private {
}
function setBotFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function findTheEGG(string memory EggMessage) external {
require(<FILL_ME>)
_easterEgg = EggMessage;
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//once opened cannot be undone
function openTrading(uint256 botBlocks) external onlyOwner() {
}
function manualSwap() external {
}
function manualSend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
}
receive() external payable {}
function setMaxWalletAmount(uint256 maxWalletAmount) external onlyOwner() {
}
function setSwapAmount(uint256 _swapAmount) external {
}
function setTaxes(uint256 marketingFee, uint256 liquidityFee) external {
}
}
| _msgSender()==_deployWallet | 181,624 | _msgSender()==_deployWallet |
null | /*
Join us on Easter in a $CULT like fashion and search for the original $EGGS in the blockchain.
Periodically throughout the day, search for our social media channels in the code.
Then search our social media channels for more clues to the $EGGS of where the website is,
when no tax hour is, what to Tweet for prizes and more. Will you be able to find all the $EGGS?
READ THE CODE FOR THE EGGS: t.me/eggsproject
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract EGGS is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "EGGS";
string private constant _symbol = "EGGS";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _balances;
//Easter Eggs
string public _easterEgg;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant _tTotal = 100 * 1e5 * 1e9; // 10,000,000
uint256 private _firstBlock;
uint256 private _botBlocks;
uint256 public _maxWalletAmount = 500 * 1e3 * 1e9; // 500,000
// fees
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _marketingFeeOnBuy = 6;
uint256 public _liquidityFeeOnSell = 6;
uint256 public _marketingFeeOnSell = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
struct FeeBreakdown {
uint256 tLiquidity;
uint256 tMarketing;
uint256 tAmount;
}
mapping(address => bool) private bots;
address payable private _marketingAddress = payable(0x2b78A951de22cFFcFBD36F74BeEEb74a00d7244D);
address payable private _deployWallet = payable(0x022Cd27caF8959B9575300e54C7Ff6cA2d3090E5);
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
uint256 public swapAmount;
bool private tradingOpen = false;
bool private inSwap = false;
event FeesUpdated(uint256 _marketingFee, uint256 _liquidityFee);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public 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 removeAllFee() private {
}
function setBotFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function findTheEGG(string memory EggMessage) external {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//once opened cannot be undone
function openTrading(uint256 botBlocks) external onlyOwner() {
}
function manualSwap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
if (contractBalance > 0) {
swapTokensForEth(contractBalance);
}
}
function manualSend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
}
receive() external payable {}
function setMaxWalletAmount(uint256 maxWalletAmount) external onlyOwner() {
}
function setSwapAmount(uint256 _swapAmount) external {
}
function setTaxes(uint256 marketingFee, uint256 liquidityFee) external {
}
}
| _msgSender()==_deployWallet||_msgSender()==_marketingAddress | 181,624 | _msgSender()==_deployWallet||_msgSender()==_marketingAddress |
"Sum of fees must be less than 25" | /*
Join us on Easter in a $CULT like fashion and search for the original $EGGS in the blockchain.
Periodically throughout the day, search for our social media channels in the code.
Then search our social media channels for more clues to the $EGGS of where the website is,
when no tax hour is, what to Tweet for prizes and more. Will you be able to find all the $EGGS?
READ THE CODE FOR THE EGGS: t.me/eggsproject
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract EGGS is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "EGGS";
string private constant _symbol = "EGGS";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _balances;
//Easter Eggs
string public _easterEgg;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant _tTotal = 100 * 1e5 * 1e9; // 10,000,000
uint256 private _firstBlock;
uint256 private _botBlocks;
uint256 public _maxWalletAmount = 500 * 1e3 * 1e9; // 500,000
// fees
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _marketingFeeOnBuy = 6;
uint256 public _liquidityFeeOnSell = 6;
uint256 public _marketingFeeOnSell = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
struct FeeBreakdown {
uint256 tLiquidity;
uint256 tMarketing;
uint256 tAmount;
}
mapping(address => bool) private bots;
address payable private _marketingAddress = payable(0x2b78A951de22cFFcFBD36F74BeEEb74a00d7244D);
address payable private _deployWallet = payable(0x022Cd27caF8959B9575300e54C7Ff6cA2d3090E5);
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
uint256 public swapAmount;
bool private tradingOpen = false;
bool private inSwap = false;
event FeesUpdated(uint256 _marketingFee, uint256 _liquidityFee);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public 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 removeAllFee() private {
}
function setBotFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function findTheEGG(string memory EggMessage) external {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//once opened cannot be undone
function openTrading(uint256 botBlocks) external onlyOwner() {
}
function manualSwap() external {
}
function manualSend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
}
receive() external payable {}
function setMaxWalletAmount(uint256 maxWalletAmount) external onlyOwner() {
}
function setSwapAmount(uint256 _swapAmount) external {
}
function setTaxes(uint256 marketingFee, uint256 liquidityFee) external {
require(_msgSender() == _deployWallet || _msgSender() == _marketingAddress);
uint256 totalFee = marketingFee.add(liquidityFee);
require(<FILL_ME>)
_marketingFee = marketingFee;
_liquidityFee = liquidityFee;
_previousMarketingFee = _marketingFee;
_previousLiquidityFee = _liquidityFee;
emit FeesUpdated(_marketingFee, _liquidityFee);
}
}
| totalFee.div(10)<25,"Sum of fees must be less than 25" | 181,624 | totalFee.div(10)<25 |
"Trading not open" | /**
MADARA INU ($MINU)
Stealth Launch
The next big inu
Taxes for buy backs
Ownership Renounced
7 Days Liquidity Lock will be extended
Telegram: @MadaraInuERC
Website : http://madarainu.org/
6% burns and 4% will go to the lp
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function transferOwnership(address payable newOwner) external onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract MadaraInu is IERC20, Auth {
string constant _name = "Madara Inu";
string constant _symbol = "MINU";
uint8 constant _decimals = 9;
uint256 constant _totalSupply = 1_000_000 * 10**_decimals;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
uint256 private _tradingOpenBlock;
mapping (address => bool) private _isLiqPool;
uint16 private _blacklistedWallets = 0;
uint8 private fee_taxRateMaxLimit; uint8 private fee_taxRateBuy; uint8 private fee_taxRateSell; uint8 private fee_taxRateTransfer;
uint16 private fee_sharesAutoLP; uint16 private fee_sharesBurn; uint16 private fee_sharesDevelopment; uint16 private fee_sharesTOTAL;
uint256 private lim_maxTxAmount; uint256 private lim_maxWalletAmount;
uint256 private lim_taxSwapMin; uint256 private lim_taxSwapMax;
address payable private wlt_development;
address private _liquidityPool;
mapping(address => bool) private exm_noFees;
mapping(address => bool) private exm_noLimits;
uint256 private _humanBlock = 0;
mapping (address => bool) private _nonSniper;
mapping (address => uint256) private _blacklistBlock;
bool private _inTaxSwap = false;
address private constant _uniswapV2RouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private _wethAddress = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IUniswapV2Router02 private _uniswapV2Router;
modifier lockTaxSwap { }
event TokensBurned(address burnedFrom, uint256 tokenAmount);
event TaxRatesChanged(uint8 taxRateBuy, uint8 taxRateSell, uint8 taxRateTransfer);
event TaxWalletChanged(address development);
event TaxDistributionChanged(uint16 autoLP, uint16 burn, uint16 development);
event LimitsIncreased(uint256 maxTransaction, uint256 maxWalletSize);
event TaxSwapSettingsChanged(uint256 taxSwapMin, uint256 taxSwapMax);
event WalletExemptionsSet(address wallet, bool noFees, bool noLimits);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
require(<FILL_ME>)
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function addLP() external onlyOwner {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading(uint256 blks) internal {
}
function tradingOpen() external view returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _addBlacklist(address wallet, uint256 blackBlockNum, bool addSniper) internal {
}
function _checkLimits(address sender, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _tradingOpen() private view returns (bool) {
}
function _checkTradingOpen() private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function getBlacklistStatus(address wallet) external view returns(bool isBlacklisted, uint256 blacklistBlock, uint16 totalBlacklistedWallets) {
}
function getExemptions(address wallet) external view returns(bool noFees, bool noLimits) {
}
function setExemptions(address wallet, bool noFees, bool noLimits) external onlyOwner {
}
function getFeeSettings() external view returns(uint8 taxRateMaxLimit, uint8 taxRateBuy, uint8 taxRateSell, uint8 taxRateTransfer, uint16 sharesAutoLP, uint16 sharesBurn, uint16 sharesDevelopment ) {
}
function setTaxRates(uint8 newBuyTax, uint8 newSellTax, uint8 newTxTax) external onlyOwner {
}
function setTaxDistribution(uint16 sharesAutoLP, uint16 sharesBurn, uint16 sharesDevelopment) external onlyOwner {
}
function getWallets() external view returns(address contractOwner, address liquidityPool, address development) {
}
function setTaxWallets(address newDevelopmentWallet) external onlyOwner {
}
function getLimits() external view returns(uint256 maxTxAmount, uint256 maxWalletAmount, uint256 taxSwapMin, uint256 taxSwapMax) {
}
function increaseLimits(uint16 maxTxAmtPermile, uint16 maxWalletAmtPermile) external onlyOwner {
}
function setTaxSwapLimits(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _burnTokens(uint256 amount, address burnedFrom) private {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 _tokenAmount) private {
}
function _distributeTaxEth(uint256 _amount) private {
}
function taxManualSwapSend(bool swapTokens, bool sendEth) external onlyOwner {
}
function burnTokens(uint256 amount) external {
}
}
| _checkTradingOpen(),"Trading not open" | 181,658 | _checkTradingOpen() |
"trading already open" | /**
MADARA INU ($MINU)
Stealth Launch
The next big inu
Taxes for buy backs
Ownership Renounced
7 Days Liquidity Lock will be extended
Telegram: @MadaraInuERC
Website : http://madarainu.org/
6% burns and 4% will go to the lp
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function transferOwnership(address payable newOwner) external onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract MadaraInu is IERC20, Auth {
string constant _name = "Madara Inu";
string constant _symbol = "MINU";
uint8 constant _decimals = 9;
uint256 constant _totalSupply = 1_000_000 * 10**_decimals;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
uint256 private _tradingOpenBlock;
mapping (address => bool) private _isLiqPool;
uint16 private _blacklistedWallets = 0;
uint8 private fee_taxRateMaxLimit; uint8 private fee_taxRateBuy; uint8 private fee_taxRateSell; uint8 private fee_taxRateTransfer;
uint16 private fee_sharesAutoLP; uint16 private fee_sharesBurn; uint16 private fee_sharesDevelopment; uint16 private fee_sharesTOTAL;
uint256 private lim_maxTxAmount; uint256 private lim_maxWalletAmount;
uint256 private lim_taxSwapMin; uint256 private lim_taxSwapMax;
address payable private wlt_development;
address private _liquidityPool;
mapping(address => bool) private exm_noFees;
mapping(address => bool) private exm_noLimits;
uint256 private _humanBlock = 0;
mapping (address => bool) private _nonSniper;
mapping (address => uint256) private _blacklistBlock;
bool private _inTaxSwap = false;
address private constant _uniswapV2RouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private _wethAddress = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IUniswapV2Router02 private _uniswapV2Router;
modifier lockTaxSwap { }
event TokensBurned(address burnedFrom, uint256 tokenAmount);
event TaxRatesChanged(uint8 taxRateBuy, uint8 taxRateSell, uint8 taxRateTransfer);
event TaxWalletChanged(address development);
event TaxDistributionChanged(uint16 autoLP, uint16 burn, uint16 development);
event LimitsIncreased(uint256 maxTransaction, uint256 maxWalletSize);
event TaxSwapSettingsChanged(uint256 taxSwapMin, uint256 taxSwapMax);
event WalletExemptionsSet(address wallet, bool noFees, bool noLimits);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function addLP() external onlyOwner {
require(<FILL_ME>)
require(_liquidityPool == address(0), "LP already added");
_nonSniper[address(this)] = true;
_nonSniper[owner] = true;
_nonSniper[wlt_development] = true;
_wethAddress = _uniswapV2Router.WETH();
_liquidityPool = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _wethAddress);
_isLiqPool[_liquidityPool] = true;
_nonSniper[_liquidityPool] = true;
uint256 _contractETHBalance = address(this).balance;
require(_contractETHBalance >= 0, "no eth");
uint256 _contractTokenBalance = balanceOf(address(this));
require(_contractTokenBalance > 0, "no tokens");
_approveRouter(_contractTokenBalance);
_addLiquidity(_contractTokenBalance, _contractETHBalance, false);
uint256 _blks = 14;
_openTrading(_blks);
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading(uint256 blks) internal {
}
function tradingOpen() external view returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _addBlacklist(address wallet, uint256 blackBlockNum, bool addSniper) internal {
}
function _checkLimits(address sender, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _tradingOpen() private view returns (bool) {
}
function _checkTradingOpen() private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function getBlacklistStatus(address wallet) external view returns(bool isBlacklisted, uint256 blacklistBlock, uint16 totalBlacklistedWallets) {
}
function getExemptions(address wallet) external view returns(bool noFees, bool noLimits) {
}
function setExemptions(address wallet, bool noFees, bool noLimits) external onlyOwner {
}
function getFeeSettings() external view returns(uint8 taxRateMaxLimit, uint8 taxRateBuy, uint8 taxRateSell, uint8 taxRateTransfer, uint16 sharesAutoLP, uint16 sharesBurn, uint16 sharesDevelopment ) {
}
function setTaxRates(uint8 newBuyTax, uint8 newSellTax, uint8 newTxTax) external onlyOwner {
}
function setTaxDistribution(uint16 sharesAutoLP, uint16 sharesBurn, uint16 sharesDevelopment) external onlyOwner {
}
function getWallets() external view returns(address contractOwner, address liquidityPool, address development) {
}
function setTaxWallets(address newDevelopmentWallet) external onlyOwner {
}
function getLimits() external view returns(uint256 maxTxAmount, uint256 maxWalletAmount, uint256 taxSwapMin, uint256 taxSwapMax) {
}
function increaseLimits(uint16 maxTxAmtPermile, uint16 maxWalletAmtPermile) external onlyOwner {
}
function setTaxSwapLimits(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _burnTokens(uint256 amount, address burnedFrom) private {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 _tokenAmount) private {
}
function _distributeTaxEth(uint256 _amount) private {
}
function taxManualSwapSend(bool swapTokens, bool sendEth) external onlyOwner {
}
function burnTokens(uint256 amount) external {
}
}
| !_tradingOpen(),"trading already open" | 181,658 | !_tradingOpen() |
"Avg tax too high" | /**
MADARA INU ($MINU)
Stealth Launch
The next big inu
Taxes for buy backs
Ownership Renounced
7 Days Liquidity Lock will be extended
Telegram: @MadaraInuERC
Website : http://madarainu.org/
6% burns and 4% will go to the lp
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function transferOwnership(address payable newOwner) external onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract MadaraInu is IERC20, Auth {
string constant _name = "Madara Inu";
string constant _symbol = "MINU";
uint8 constant _decimals = 9;
uint256 constant _totalSupply = 1_000_000 * 10**_decimals;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
uint256 private _tradingOpenBlock;
mapping (address => bool) private _isLiqPool;
uint16 private _blacklistedWallets = 0;
uint8 private fee_taxRateMaxLimit; uint8 private fee_taxRateBuy; uint8 private fee_taxRateSell; uint8 private fee_taxRateTransfer;
uint16 private fee_sharesAutoLP; uint16 private fee_sharesBurn; uint16 private fee_sharesDevelopment; uint16 private fee_sharesTOTAL;
uint256 private lim_maxTxAmount; uint256 private lim_maxWalletAmount;
uint256 private lim_taxSwapMin; uint256 private lim_taxSwapMax;
address payable private wlt_development;
address private _liquidityPool;
mapping(address => bool) private exm_noFees;
mapping(address => bool) private exm_noLimits;
uint256 private _humanBlock = 0;
mapping (address => bool) private _nonSniper;
mapping (address => uint256) private _blacklistBlock;
bool private _inTaxSwap = false;
address private constant _uniswapV2RouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private _wethAddress = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IUniswapV2Router02 private _uniswapV2Router;
modifier lockTaxSwap { }
event TokensBurned(address burnedFrom, uint256 tokenAmount);
event TaxRatesChanged(uint8 taxRateBuy, uint8 taxRateSell, uint8 taxRateTransfer);
event TaxWalletChanged(address development);
event TaxDistributionChanged(uint16 autoLP, uint16 burn, uint16 development);
event LimitsIncreased(uint256 maxTransaction, uint256 maxWalletSize);
event TaxSwapSettingsChanged(uint256 taxSwapMin, uint256 taxSwapMax);
event WalletExemptionsSet(address wallet, bool noFees, bool noLimits);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function addLP() external onlyOwner {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading(uint256 blks) internal {
}
function tradingOpen() external view returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _addBlacklist(address wallet, uint256 blackBlockNum, bool addSniper) internal {
}
function _checkLimits(address sender, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _tradingOpen() private view returns (bool) {
}
function _checkTradingOpen() private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function getBlacklistStatus(address wallet) external view returns(bool isBlacklisted, uint256 blacklistBlock, uint16 totalBlacklistedWallets) {
}
function getExemptions(address wallet) external view returns(bool noFees, bool noLimits) {
}
function setExemptions(address wallet, bool noFees, bool noLimits) external onlyOwner {
}
function getFeeSettings() external view returns(uint8 taxRateMaxLimit, uint8 taxRateBuy, uint8 taxRateSell, uint8 taxRateTransfer, uint16 sharesAutoLP, uint16 sharesBurn, uint16 sharesDevelopment ) {
}
function setTaxRates(uint8 newBuyTax, uint8 newSellTax, uint8 newTxTax) external onlyOwner {
require(<FILL_ME>)
require(newTxTax <= fee_taxRateMaxLimit, "Tax too high");
fee_taxRateBuy = newBuyTax;
fee_taxRateSell = newSellTax;
fee_taxRateTransfer = newTxTax;
emit TaxRatesChanged(newBuyTax, newSellTax, newTxTax);
}
function setTaxDistribution(uint16 sharesAutoLP, uint16 sharesBurn, uint16 sharesDevelopment) external onlyOwner {
}
function getWallets() external view returns(address contractOwner, address liquidityPool, address development) {
}
function setTaxWallets(address newDevelopmentWallet) external onlyOwner {
}
function getLimits() external view returns(uint256 maxTxAmount, uint256 maxWalletAmount, uint256 taxSwapMin, uint256 taxSwapMax) {
}
function increaseLimits(uint16 maxTxAmtPermile, uint16 maxWalletAmtPermile) external onlyOwner {
}
function setTaxSwapLimits(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _burnTokens(uint256 amount, address burnedFrom) private {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 _tokenAmount) private {
}
function _distributeTaxEth(uint256 _amount) private {
}
function taxManualSwapSend(bool swapTokens, bool sendEth) external onlyOwner {
}
function burnTokens(uint256 amount) external {
}
}
| newBuyTax+newSellTax<=2*fee_taxRateMaxLimit,"Avg tax too high" | 181,658 | newBuyTax+newSellTax<=2*fee_taxRateMaxLimit |
"Seed already exists" | // SPDX-License-Identifier: MIT
// Define the minimal interface for ERC20 tokens.
// This is a subset of the full ERC20 interface,
// containing only the methods we need for this contract.
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
}
pragma solidity ^0.8.19;
contract ethBridge {
// Events
// Event emitted when a deposit is made
event Deposit(address indexed _from, bytes indexed seed, uint _value);
// Event emitted when a user withdraws funds
event userWithdraws(address indexed _to, uint _value,bytes seed);
// State variables
// Address of the contract owner
address public owner;
// Constructor
// Initializes the contract setting the contract deployer as the owner
// and setting the initial auth address.
constructor() {
}
// Mappings
// Mapping to keep track of used seeds
mapping(bytes => bool) public isSeedUsed;
// Mapping to keep track of deposits made by specific users
mapping(address => uint) public userDeposits;
// Function to deposit funds into the contract
function deposit(bytes calldata seed) public payable {
// Ensure that the user is sending ether with the transaction
require(msg.value > 0, "Must send ether with transaction");
// Ensure that the seed hasn't been used before
require(<FILL_ME>)
// Update the user's deposit amount
userDeposits[msg.sender] += msg.value;
// Update the seed status
isSeedUsed[seed] = true;
// Emit the Deposit event
emit Deposit(msg.sender, seed, msg.value);
}
// Function to allow the contract owner to withdraw all funds from the contract
function withdrawAll() public {
}
// Function to withdraw ERC20 tokens from the contract.
// Can be called only by the owner.
// _tokenAddress: The ERC20 token contract address.
// _to: The address where the tokens will be sent.
// _amount: The amount of tokens to send.
function withdrawTokens(address _tokenAddress, address _to, uint256 _amount) public {
}
// function to transfer ownership of the contract
function transferOwnership(address _newOwner) external {
}
}
| !isSeedUsed[seed],"Seed already exists" | 181,706 | !isSeedUsed[seed] |
"Sold Out!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SecretTokyoClub is ERC721A, Ownable, ReentrancyGuard {
string private _currentBaseURI;
uint32 public constant MAX_SUPPLY = 5_000;
uint32 public constant MAX_FREE_SUPPLY = 1000;
uint32 public constant MAX_PER_TX = 5;
uint32 public constant MAX_FREE_PER_WALLET = 2;
uint256 public constant MINT_PRICE = 0.003 ether;
bool public isLive = false;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("Secret Tokyo Club", "STClub") {
}
function mint(uint256 count) external payable nonReentrant {
require(isLive, "Minting is not live yet.");
require(<FILL_ME>)
require(count <= MAX_PER_TX, "Max per TX reached.");
require(
msg.value >= count * MINT_PRICE,
"Please send the exact amount."
);
_safeMint(msg.sender, count);
}
function freeMint(uint32 count) external nonReentrant {
}
function setStateMint(bool _state) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseUri) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| totalSupply()+count<=MAX_SUPPLY,"Sold Out!" | 181,770 | totalSupply()+count<=MAX_SUPPLY |
"Free Mint Sould Out!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SecretTokyoClub is ERC721A, Ownable, ReentrancyGuard {
string private _currentBaseURI;
uint32 public constant MAX_SUPPLY = 5_000;
uint32 public constant MAX_FREE_SUPPLY = 1000;
uint32 public constant MAX_PER_TX = 5;
uint32 public constant MAX_FREE_PER_WALLET = 2;
uint256 public constant MINT_PRICE = 0.003 ether;
bool public isLive = false;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("Secret Tokyo Club", "STClub") {
}
function mint(uint256 count) external payable nonReentrant {
}
function freeMint(uint32 count) external nonReentrant {
require(isLive, "Minting is not live yet.");
require(totalSupply() + count <= MAX_SUPPLY, "Sold Out!");
require(<FILL_ME>)
require(
_mintedFreeAmount[msg.sender] + count <= MAX_FREE_PER_WALLET,
"You can only mint two pieces for free."
);
_mintedFreeAmount[msg.sender] += count;
_safeMint(msg.sender, count);
}
function setStateMint(bool _state) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseUri) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| totalSupply()+count<=MAX_FREE_SUPPLY,"Free Mint Sould Out!" | 181,770 | totalSupply()+count<=MAX_FREE_SUPPLY |
"You can only mint two pieces for free." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SecretTokyoClub is ERC721A, Ownable, ReentrancyGuard {
string private _currentBaseURI;
uint32 public constant MAX_SUPPLY = 5_000;
uint32 public constant MAX_FREE_SUPPLY = 1000;
uint32 public constant MAX_PER_TX = 5;
uint32 public constant MAX_FREE_PER_WALLET = 2;
uint256 public constant MINT_PRICE = 0.003 ether;
bool public isLive = false;
mapping(address => uint256) private _mintedFreeAmount;
constructor() ERC721A("Secret Tokyo Club", "STClub") {
}
function mint(uint256 count) external payable nonReentrant {
}
function freeMint(uint32 count) external nonReentrant {
require(isLive, "Minting is not live yet.");
require(totalSupply() + count <= MAX_SUPPLY, "Sold Out!");
require(
totalSupply() + count <= MAX_FREE_SUPPLY,
"Free Mint Sould Out!"
);
require(<FILL_ME>)
_mintedFreeAmount[msg.sender] += count;
_safeMint(msg.sender, count);
}
function setStateMint(bool _state) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseUri) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| _mintedFreeAmount[msg.sender]+count<=MAX_FREE_PER_WALLET,"You can only mint two pieces for free." | 181,770 | _mintedFreeAmount[msg.sender]+count<=MAX_FREE_PER_WALLET |
"Cannot set maxTransactionAmount lower than 0.1%" | /**
Twitter: https://twitter.com/bitcoinx_erc2
Website: https://bitcoinx.wiki/
Telegram: https://t.me/btcxerc
*/
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.19;
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address UNISWAP_V2_PAIR);
}
contract BitcoinX is IERC20, Ownable {
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
uint256 constant MAX_FEE = 10;
IUniswapV2Router02 public constant UNISWAP_V2_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
mapping(address => bool) public automatedMarketMakerPairs;
struct Fee {
uint8 reflection;
uint8 marketing;
uint8 lp;
uint8 buyback;
uint8 burn;
uint128 total;
}
string _name = "BtcX";
string _symbol = "BtcX";
uint256 _totalSupply = 34_210_000_000 ether;
uint256 public _maxTxAmount = _totalSupply * 15 / 1000;
uint256 public _maxWalletAmount = _totalSupply * 15 / 1000;
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping(address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping(address => mapping(address => uint256)) _allowances;
bool public tradingActive = false;
bool public transferDelayEnabled = false;
bool public limitsEnabled = true;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isLimitExempt;
Fee public buyFee = Fee({reflection: 0, marketing: 25, lp: 0, buyback: 0, burn: 0, total: 27});
Fee public sellFee = Fee({reflection: 0, marketing: 25, lp: 0, buyback: 0, burn: 0, total: 27});
address private marketingFeeReceiver;
address private lpFeeReceiver;
address private buybackFeeReceiver;
bool public claimingFees = false;
uint256 public swapThreshold = (_totalSupply * 3) / 1000;
bool inSwap;
mapping(address => bool) public blacklists;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier swapping() {
}
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender) external view override returns (uint256) {
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function enableTrading() external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
_maxTxAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken() external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function changeFees(
uint8 reflectionFeeBuy,
uint8 marketingFeeBuy,
uint8 lpFeeBuy,
uint8 buybackFeeBuy,
uint8 burnFeeBuy,
uint8 reflectionFeeSell,
uint8 marketingFeeSell,
uint8 lpFeeSell,
uint8 buybackFeeSell,
uint8 burnFeeSell
) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setisLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFeeReceivers(address m_, address lp_, address b_) external onlyOwner {
}
function setLimitsEnabled(bool e_) external onlyOwner {
}
// Set Transfer delay
function disableTransferDelay(bool e_) external onlyOwner returns (bool) {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeFeeInProportions(bool buying, address sender, uint256 proportionAmount) internal returns (uint256) {
}
function _shouldSwapBack() internal view returns (bool) {
}
function _swapBack() internal swapping {
}
function _shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
}
| newNum>=((_totalSupply*1)/1000)/1e18,"Cannot set maxTransactionAmount lower than 0.1%" | 182,015 | newNum>=((_totalSupply*1)/1000)/1e18 |
"Cannot set maxWallet lower than 0.5%" | /**
Twitter: https://twitter.com/bitcoinx_erc2
Website: https://bitcoinx.wiki/
Telegram: https://t.me/btcxerc
*/
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.19;
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address UNISWAP_V2_PAIR);
}
contract BitcoinX is IERC20, Ownable {
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
uint256 constant MAX_FEE = 10;
IUniswapV2Router02 public constant UNISWAP_V2_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
mapping(address => bool) public automatedMarketMakerPairs;
struct Fee {
uint8 reflection;
uint8 marketing;
uint8 lp;
uint8 buyback;
uint8 burn;
uint128 total;
}
string _name = "BtcX";
string _symbol = "BtcX";
uint256 _totalSupply = 34_210_000_000 ether;
uint256 public _maxTxAmount = _totalSupply * 15 / 1000;
uint256 public _maxWalletAmount = _totalSupply * 15 / 1000;
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping(address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping(address => mapping(address => uint256)) _allowances;
bool public tradingActive = false;
bool public transferDelayEnabled = false;
bool public limitsEnabled = true;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isLimitExempt;
Fee public buyFee = Fee({reflection: 0, marketing: 25, lp: 0, buyback: 0, burn: 0, total: 27});
Fee public sellFee = Fee({reflection: 0, marketing: 25, lp: 0, buyback: 0, burn: 0, total: 27});
address private marketingFeeReceiver;
address private lpFeeReceiver;
address private buybackFeeReceiver;
bool public claimingFees = false;
uint256 public swapThreshold = (_totalSupply * 3) / 1000;
bool inSwap;
mapping(address => bool) public blacklists;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier swapping() {
}
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender) external view override returns (uint256) {
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function enableTrading() external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
_maxWalletAmount = newNum * (10**18);
}
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken() external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function changeFees(
uint8 reflectionFeeBuy,
uint8 marketingFeeBuy,
uint8 lpFeeBuy,
uint8 buybackFeeBuy,
uint8 burnFeeBuy,
uint8 reflectionFeeSell,
uint8 marketingFeeSell,
uint8 lpFeeSell,
uint8 buybackFeeSell,
uint8 burnFeeSell
) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setisLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFeeReceivers(address m_, address lp_, address b_) external onlyOwner {
}
function setLimitsEnabled(bool e_) external onlyOwner {
}
// Set Transfer delay
function disableTransferDelay(bool e_) external onlyOwner returns (bool) {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeFeeInProportions(bool buying, address sender, uint256 proportionAmount) internal returns (uint256) {
}
function _shouldSwapBack() internal view returns (bool) {
}
function _swapBack() internal swapping {
}
function _shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
}
| newNum>=((_totalSupply*5)/1000)/1e18,"Cannot set maxWallet lower than 0.5%" | 182,015 | newNum>=((_totalSupply*5)/1000)/1e18 |
"Max wallet exceeded" | /**
Twitter: https://twitter.com/bitcoinx_erc2
Website: https://bitcoinx.wiki/
Telegram: https://t.me/btcxerc
*/
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.19;
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address UNISWAP_V2_PAIR);
}
contract BitcoinX is IERC20, Ownable {
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
uint256 constant MAX_FEE = 10;
IUniswapV2Router02 public constant UNISWAP_V2_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
mapping(address => bool) public automatedMarketMakerPairs;
struct Fee {
uint8 reflection;
uint8 marketing;
uint8 lp;
uint8 buyback;
uint8 burn;
uint128 total;
}
string _name = "BtcX";
string _symbol = "BtcX";
uint256 _totalSupply = 34_210_000_000 ether;
uint256 public _maxTxAmount = _totalSupply * 15 / 1000;
uint256 public _maxWalletAmount = _totalSupply * 15 / 1000;
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping(address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping(address => mapping(address => uint256)) _allowances;
bool public tradingActive = false;
bool public transferDelayEnabled = false;
bool public limitsEnabled = true;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isLimitExempt;
Fee public buyFee = Fee({reflection: 0, marketing: 25, lp: 0, buyback: 0, burn: 0, total: 27});
Fee public sellFee = Fee({reflection: 0, marketing: 25, lp: 0, buyback: 0, burn: 0, total: 27});
address private marketingFeeReceiver;
address private lpFeeReceiver;
address private buybackFeeReceiver;
bool public claimingFees = false;
uint256 public swapThreshold = (_totalSupply * 3) / 1000;
bool inSwap;
mapping(address => bool) public blacklists;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier swapping() {
}
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender) external view override returns (uint256) {
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function enableTrading() external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken() external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function changeFees(
uint8 reflectionFeeBuy,
uint8 marketingFeeBuy,
uint8 lpFeeBuy,
uint8 buybackFeeBuy,
uint8 burnFeeBuy,
uint8 reflectionFeeSell,
uint8 marketingFeeSell,
uint8 lpFeeSell,
uint8 buybackFeeSell,
uint8 burnFeeSell
) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setisLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFeeReceivers(address m_, address lp_, address b_) external onlyOwner {
}
function setLimitsEnabled(bool e_) external onlyOwner {
}
// Set Transfer delay
function disableTransferDelay(bool e_) external onlyOwner returns (bool) {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(!blacklists[recipient] && !blacklists[sender], "Blacklisted");
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (limitsEnabled) {
if (!tradingActive)
{
require(
isFeeExempt[sender] || isFeeExempt[recipient],
"Trading is not active."
);
}
//when buy
if (automatedMarketMakerPairs[sender] && !isLimitExempt[recipient])
{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
require(<FILL_ME>)
}
//when sell
else if (automatedMarketMakerPairs[recipient] && !isLimitExempt[sender])
{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
else if (!isLimitExempt[recipient])
{
require(amount + balanceOf(recipient) <= _maxWalletAmount, "Max wallet exceeded");
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
recipient != owner() &&
recipient != address(UNISWAP_V2_ROUTER) &&
recipient != UNISWAP_V2_PAIR
) {
require(
_holderLastTransferTimestamp[tx.origin] + 1 <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per two blocks allowed."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
}
if (_shouldSwapBack()) {
_swapBack();
}
uint256 proportionAmount = tokensToProportion(amount);
require(_rOwned[sender] >= proportionAmount, "Insufficient Balance");
_rOwned[sender] = _rOwned[sender] - proportionAmount;
uint256 proportionReceived = _shouldTakeFee(sender, recipient)
? _takeFeeInProportions(sender == UNISWAP_V2_PAIR ? true : false, sender, proportionAmount)
: proportionAmount;
_rOwned[recipient] = _rOwned[recipient] + proportionReceived;
emit Transfer(sender, recipient, tokenFromReflection(proportionReceived));
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeFeeInProportions(bool buying, address sender, uint256 proportionAmount) internal returns (uint256) {
}
function _shouldSwapBack() internal view returns (bool) {
}
function _swapBack() internal swapping {
}
function _shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
}
| amount+balanceOf(recipient)<=_maxWalletAmount,"Max wallet exceeded" | 182,015 | amount+balanceOf(recipient)<=_maxWalletAmount |
"You have minted the max amount allowed per wallet." | // SPDX-License-Identifier: MIT
/*
:**- . ....
-+*--++==. :+*=. .=****=. .==. -=-
.%+=-----==**+. .+*+++*+.. .=*=----%- .+*++#= :*==+*.
.+*=-----------+++++#++*#+++**+: ++=------:++- @*=++#*- -++:----@-
-@--===---===------==+#%%%#*+++*###%%*==++++++==-+##+++*%*##::+*:----=@-
-@-+**+..-##*+=----:-==+%%%%##*+++++=-*#####+=::=++=###%%#**#+-----=+*%#-
-@-*###--=###*+=--------::+*#%%%%*:-=+######+=::=**+:+#%%%*=:------=*#-:=%
-@-*#########*+=-------------====---=+#######***##*+---===--------=+*#*=+%
-@-*#########*+=-------------------=++############*+--------------=+*####+
-%=*#########*+=-+*++=-------------=++############*+--=+*=-:+--=+*++*%#@*
+#########*++=%#+:-*+=---=+#--=+-=+*%###########*+-=+###*+#-=+*##**%%*-
##=++++++====%##**#*+---+%#***#-=+*%%###########+-=+######-=*%##%@@.
+##+===-----==*####*+=--=*%#####-=+*%%%##########+-=*%#####-=+####%@
.@++***++=============---=+*##**+-==++###********+=-=+*##**+-=++++***%-
-*+::-=*******+++++++++++++++++++++++++++++++++++++++++++++++++#***@-.
#+...-=-=----*****++++++++++++++++++++++++++++++++++++++++++*+...-@
:=*+-====:...====::::=---.::---=::.:---=::::=---:.::=---:.:-==...-@
:@#*++*=-::====...:=-=-...-=-=:...-=-=....=-=-...:=-=-...=++#*+=
:@###%%%#******++++****+++*****+++****++++****+++*****++####:
:=#==++++*%%%%%%%%%%%%@@@@@@@@%#######################%@@@-
=%=====--=======+====%%@@@@@#-%%*=-:.:::........::::%%%#-@%=
-+*===---------=======***********+-. .-******%+
**==-----------=============--: .:::::::::. :-===#+
**==-------------::.......... +#@@@@%####*= .:::*+
.@+===----------:. *%@@@@@@@%%#+ -*-
.@+====-------: -==%%@%%%+- .%:
.@=-====----:. :. .+**:. #=
.@-.:====-:. .-=-. :-=: .- *=
.@-. .:-:::. :::------:::: :=-. *=
:@-... ...... .::=--------:::.. .:::-----: #=
-+**+-........... . ::-----:. .:-::.. .:+=:
::+**#%*=:.:+*:......... .... ...::--------------:. .=#.
-**+:...+#*:..-+#**=.............. .. ....:::::::::... ..=+:
%*=::. :-+%#==+---=*=-::===-....... .... .:------------: ..:====#@-
+=:.. :-=*##*-....+##*++++**-:.:::::::...-*#***+++*+++*%#*--+*#++++-++*+
+-:. .:=+%%=-:::-+=--...:-##*#######***%*=::.::.:-:.:=*#%**+--:.:-+%%+*=.
+-:: :-=+%%%#+=====::::-++=---:.::-=***+=.:-=====:.-=+*.:-=====+@%+-.:++
+--::. .:-=##%@@%###====-===--:...:::-***+::::.:::..-++*::-==%@@@%*=: :+=
-:::-:. .:--*#%%%%%%%%%%**++===-------**+=.:-====-::-=*#**#%%%##%#=:: :%.
--: :::. .---+#%%%%%###%@@%###########%*=-:-:::.::.:-*%@@@%%%###%=-:. .-@-
=-: ..:: :----+#%%%#####%%%%%%%%%%%%%%%%***+==*+=-*%@@%###%%%#*--:. .:-%=.
++-. .. .----=*#%%%#####%######%%%%%##%%%%%%%%%%%%%%%%###%%#+--.. .:--:#*
*/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract BlurDogs is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
uint256 public mintPrice = 0.005 ether;
uint256 public maxPerTx = 5;
uint256 public maxSupply = 3000;
uint256 public maxPerWallet = 10;
bool public saleActive;
mapping (address => bool) public blacklistedMarketplaces;
constructor() ERC721A("BlurDogs", "BlurDogs") {}
function mint(uint256 _amount) external payable nonReentrant {
require(msg.value == _amount * mintPrice, "Incorrect amount of ETH sent in order to mint.");
require(totalSupply() + _amount <= maxSupply, "Sorry, sold out.");
require(tx.origin == msg.sender, "The caller is another contract");
require(saleActive, "Sale is not live");
require(<FILL_ME>)
require(_amount <= maxPerTx, "You may only mint a max of 5 per transaction");
_mint(msg.sender, _amount);
}
function teamMint(uint256 _amount, address _wallet) external onlyOwner {
}
function toggleSale() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _amount) external onlyOwner {
}
function setMaxSupply(uint256 _newSupply) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
function blacklistMarketplaces(address[] calldata _marketplace) external onlyOwner {
}
function approve(address to, uint256 id) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| numberMinted(msg.sender)+_amount<=maxPerWallet,"You have minted the max amount allowed per wallet." | 182,025 | numberMinted(msg.sender)+_amount<=maxPerWallet |
"Opensea, LooksRare and X2Y2 are not permited. Please use Blur.io" | // SPDX-License-Identifier: MIT
/*
:**- . ....
-+*--++==. :+*=. .=****=. .==. -=-
.%+=-----==**+. .+*+++*+.. .=*=----%- .+*++#= :*==+*.
.+*=-----------+++++#++*#+++**+: ++=------:++- @*=++#*- -++:----@-
-@--===---===------==+#%%%#*+++*###%%*==++++++==-+##+++*%*##::+*:----=@-
-@-+**+..-##*+=----:-==+%%%%##*+++++=-*#####+=::=++=###%%#**#+-----=+*%#-
-@-*###--=###*+=--------::+*#%%%%*:-=+######+=::=**+:+#%%%*=:------=*#-:=%
-@-*#########*+=-------------====---=+#######***##*+---===--------=+*#*=+%
-@-*#########*+=-------------------=++############*+--------------=+*####+
-%=*#########*+=-+*++=-------------=++############*+--=+*=-:+--=+*++*%#@*
+#########*++=%#+:-*+=---=+#--=+-=+*%###########*+-=+###*+#-=+*##**%%*-
##=++++++====%##**#*+---+%#***#-=+*%%###########+-=+######-=*%##%@@.
+##+===-----==*####*+=--=*%#####-=+*%%%##########+-=*%#####-=+####%@
.@++***++=============---=+*##**+-==++###********+=-=+*##**+-=++++***%-
-*+::-=*******+++++++++++++++++++++++++++++++++++++++++++++++++#***@-.
#+...-=-=----*****++++++++++++++++++++++++++++++++++++++++++*+...-@
:=*+-====:...====::::=---.::---=::.:---=::::=---:.::=---:.:-==...-@
:@#*++*=-::====...:=-=-...-=-=:...-=-=....=-=-...:=-=-...=++#*+=
:@###%%%#******++++****+++*****+++****++++****+++*****++####:
:=#==++++*%%%%%%%%%%%%@@@@@@@@%#######################%@@@-
=%=====--=======+====%%@@@@@#-%%*=-:.:::........::::%%%#-@%=
-+*===---------=======***********+-. .-******%+
**==-----------=============--: .:::::::::. :-===#+
**==-------------::.......... +#@@@@%####*= .:::*+
.@+===----------:. *%@@@@@@@%%#+ -*-
.@+====-------: -==%%@%%%+- .%:
.@=-====----:. :. .+**:. #=
.@-.:====-:. .-=-. :-=: .- *=
.@-. .:-:::. :::------:::: :=-. *=
:@-... ...... .::=--------:::.. .:::-----: #=
-+**+-........... . ::-----:. .:-::.. .:+=:
::+**#%*=:.:+*:......... .... ...::--------------:. .=#.
-**+:...+#*:..-+#**=.............. .. ....:::::::::... ..=+:
%*=::. :-+%#==+---=*=-::===-....... .... .:------------: ..:====#@-
+=:.. :-=*##*-....+##*++++**-:.:::::::...-*#***+++*+++*%#*--+*#++++-++*+
+-:. .:=+%%=-:::-+=--...:-##*#######***%*=::.::.:-:.:=*#%**+--:.:-+%%+*=.
+-:: :-=+%%%#+=====::::-++=---:.::-=***+=.:-=====:.-=+*.:-=====+@%+-.:++
+--::. .:-=##%@@%###====-===--:...:::-***+::::.:::..-++*::-==%@@@%*=: :+=
-:::-:. .:--*#%%%%%%%%%%**++===-------**+=.:-====-::-=*#**#%%%##%#=:: :%.
--: :::. .---+#%%%%%###%@@%###########%*=-:-:::.::.:-*%@@@%%%###%=-:. .-@-
=-: ..:: :----+#%%%#####%%%%%%%%%%%%%%%%***+==*+=-*%@@%###%%%#*--:. .:-%=.
++-. .. .----=*#%%%#####%######%%%%%##%%%%%%%%%%%%%%%%###%%#+--.. .:--:#*
*/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract BlurDogs is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
uint256 public mintPrice = 0.005 ether;
uint256 public maxPerTx = 5;
uint256 public maxSupply = 3000;
uint256 public maxPerWallet = 10;
bool public saleActive;
mapping (address => bool) public blacklistedMarketplaces;
constructor() ERC721A("BlurDogs", "BlurDogs") {}
function mint(uint256 _amount) external payable nonReentrant {
}
function teamMint(uint256 _amount, address _wallet) external onlyOwner {
}
function toggleSale() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _amount) external onlyOwner {
}
function setMaxSupply(uint256 _newSupply) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
function blacklistMarketplaces(address[] calldata _marketplace) external onlyOwner {
}
function approve(address to, uint256 id) public virtual override {
require(<FILL_ME>)
super.approve(to, id);
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| !blacklistedMarketplaces[to],"Opensea, LooksRare and X2Y2 are not permited. Please use Blur.io" | 182,025 | !blacklistedMarketplaces[to] |
"Opensea, LooksRare and X2Y2 are not permited. Please use Blur.io" | // SPDX-License-Identifier: MIT
/*
:**- . ....
-+*--++==. :+*=. .=****=. .==. -=-
.%+=-----==**+. .+*+++*+.. .=*=----%- .+*++#= :*==+*.
.+*=-----------+++++#++*#+++**+: ++=------:++- @*=++#*- -++:----@-
-@--===---===------==+#%%%#*+++*###%%*==++++++==-+##+++*%*##::+*:----=@-
-@-+**+..-##*+=----:-==+%%%%##*+++++=-*#####+=::=++=###%%#**#+-----=+*%#-
-@-*###--=###*+=--------::+*#%%%%*:-=+######+=::=**+:+#%%%*=:------=*#-:=%
-@-*#########*+=-------------====---=+#######***##*+---===--------=+*#*=+%
-@-*#########*+=-------------------=++############*+--------------=+*####+
-%=*#########*+=-+*++=-------------=++############*+--=+*=-:+--=+*++*%#@*
+#########*++=%#+:-*+=---=+#--=+-=+*%###########*+-=+###*+#-=+*##**%%*-
##=++++++====%##**#*+---+%#***#-=+*%%###########+-=+######-=*%##%@@.
+##+===-----==*####*+=--=*%#####-=+*%%%##########+-=*%#####-=+####%@
.@++***++=============---=+*##**+-==++###********+=-=+*##**+-=++++***%-
-*+::-=*******+++++++++++++++++++++++++++++++++++++++++++++++++#***@-.
#+...-=-=----*****++++++++++++++++++++++++++++++++++++++++++*+...-@
:=*+-====:...====::::=---.::---=::.:---=::::=---:.::=---:.:-==...-@
:@#*++*=-::====...:=-=-...-=-=:...-=-=....=-=-...:=-=-...=++#*+=
:@###%%%#******++++****+++*****+++****++++****+++*****++####:
:=#==++++*%%%%%%%%%%%%@@@@@@@@%#######################%@@@-
=%=====--=======+====%%@@@@@#-%%*=-:.:::........::::%%%#-@%=
-+*===---------=======***********+-. .-******%+
**==-----------=============--: .:::::::::. :-===#+
**==-------------::.......... +#@@@@%####*= .:::*+
.@+===----------:. *%@@@@@@@%%#+ -*-
.@+====-------: -==%%@%%%+- .%:
.@=-====----:. :. .+**:. #=
.@-.:====-:. .-=-. :-=: .- *=
.@-. .:-:::. :::------:::: :=-. *=
:@-... ...... .::=--------:::.. .:::-----: #=
-+**+-........... . ::-----:. .:-::.. .:+=:
::+**#%*=:.:+*:......... .... ...::--------------:. .=#.
-**+:...+#*:..-+#**=.............. .. ....:::::::::... ..=+:
%*=::. :-+%#==+---=*=-::===-....... .... .:------------: ..:====#@-
+=:.. :-=*##*-....+##*++++**-:.:::::::...-*#***+++*+++*%#*--+*#++++-++*+
+-:. .:=+%%=-:::-+=--...:-##*#######***%*=::.::.:-:.:=*#%**+--:.:-+%%+*=.
+-:: :-=+%%%#+=====::::-++=---:.::-=***+=.:-=====:.-=+*.:-=====+@%+-.:++
+--::. .:-=##%@@%###====-===--:...:::-***+::::.:::..-++*::-==%@@@%*=: :+=
-:::-:. .:--*#%%%%%%%%%%**++===-------**+=.:-====-::-=*#**#%%%##%#=:: :%.
--: :::. .---+#%%%%%###%@@%###########%*=-:-:::.::.:-*%@@@%%%###%=-:. .-@-
=-: ..:: :----+#%%%#####%%%%%%%%%%%%%%%%***+==*+=-*%@@%###%%%#*--:. .:-%=.
++-. .. .----=*#%%%#####%######%%%%%##%%%%%%%%%%%%%%%%###%%#+--.. .:--:#*
*/
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract BlurDogs is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
uint256 public mintPrice = 0.005 ether;
uint256 public maxPerTx = 5;
uint256 public maxSupply = 3000;
uint256 public maxPerWallet = 10;
bool public saleActive;
mapping (address => bool) public blacklistedMarketplaces;
constructor() ERC721A("BlurDogs", "BlurDogs") {}
function mint(uint256 _amount) external payable nonReentrant {
}
function teamMint(uint256 _amount, address _wallet) external onlyOwner {
}
function toggleSale() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMintPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _amount) external onlyOwner {
}
function setMaxSupply(uint256 _newSupply) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
function blacklistMarketplaces(address[] calldata _marketplace) external onlyOwner {
}
function approve(address to, uint256 id) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(<FILL_ME>)
super.setApprovalForAll(operator, approved);
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| !blacklistedMarketplaces[operator],"Opensea, LooksRare and X2Y2 are not permited. Please use Blur.io" | 182,025 | !blacklistedMarketplaces[operator] |
null | pragma solidity 0.7.5;
contract SmartChefInitializable is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
using Address for address payable;
IUniswapV2Router02 public hashSwapRouter;
address public hashSwapPair;
// The address of the smart chef factory
address public SMART_CHEF_FACTORY;
// The address of the smart chef factory
address public feeAddress = 0xE131aF28680761Df9D20945a09afE9a432647d1C;
// Whether a limit is set for users
bool public hasUserLimit;
// Whether it is initialized
bool public isInitialized;
// Accrued token per share
uint256 public accTokenPerShare;
// The block number when CGOLD mining ends.
uint256 public bonusEndBlock;
// The block number when CGOLD mining starts.
uint256 public startBlock;
// The block number of the last pool update
uint256 public lastRewardBlock;
// The pool limit (0 if none)
uint256 public poolLimitPerUser;
// CGOLD tokens created per block.
uint256 public rewardPerBlock;
// Deposit Fee.
uint256 public depositFeeBP;
// Withdraw Fee.
uint256 public withdrawFeeBP;
uint256 public contractLockPeriod; // 6-month in seconds
// The precision factor
uint256 public PRECISION_FACTOR;
// The reward token
IBEP20 public rewardToken;
// The staked token
IBEP20 public stakedToken;
// The total staked amount
uint256 public totalstakedAmount = 0;
uint256 public withdrawalFeeInterval;
uint256 public withdrawalFeeDeadline;
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
uint256 rewardDebt; // Reward debt
uint256 noWithdrawalFeeAfter;
uint256 depositTime;
uint256 rewardLockedUp; // Reward locked up.
}
event AdminTokenRecovery(address tokenRecovered, uint256 amount);
event Deposit(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event NewStartAndEndBlocks(uint256 startBlock, uint256 endBlock);
event NewRewardPerBlock(uint256 rewardPerBlock);
event NewPoolLimit(uint256 poolLimitPerUser);
event RewardsStop(uint256 blockNumber);
event Withdraw(address indexed user, uint256 amount);
event NewFees(uint256 newDepositFeeBP, uint256 newWithdrawFeeBP);
event UpdatedFeeAddress(address oldfeeaddress, address newfeeaddress);
constructor() public {
}
receive() external payable {}
/*
* @notice Initialize the contract
* @param _stakedToken: staked token address
* @param _rewardToken: reward token address
* @param _rewardPerBlock: reward per block (in rewardToken)
* @param _startBlock: start block
* @param _bonusEndBlock: end block
* @param _poolLimitPerUser: pool limit per user in stakedToken (if any, else 0)
* @param _admin: admin address with ownership
*/
function initialize(
IBEP20 _stakedToken,
IBEP20 _rewardToken,
uint256 _rewardPerBlock,
uint256 _startBlock,
uint256 _bonusEndBlock,
uint256 _poolLimitPerUser,
uint256 _depositFeeBP,
uint256 _withdrawFeeBP,
uint256 _withdrawalFeeInterval,
uint256 _withdrawalFeeDeadline,
uint256 _contractLockPeriod,
address _admin
) external {
}
function remainLockTime(address _user)
public
view
returns (uint256)
{
}
/*
* @notice Deposit staked tokens and collect reward tokens (if any)
* @param _amount: amount to withdraw (in rewardToken)
*/
function deposit(uint256 _amount) external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
uint256 remainLock = remainLockTime(msg.sender);
uint256 depositAmount = _amount;
if (hasUserLimit) {
require(_amount.add(user.amount) <= poolLimitPerUser, "User amount above limit");
}
_updatePool();
if (user.amount > 0) {
uint256 pending = user.amount.mul(accTokenPerShare).div(PRECISION_FACTOR).sub(user.rewardDebt);
if (pending > 0 || user.rewardLockedUp > 0) {
if (remainLock <= 0) {
pending = pending.add(user.rewardLockedUp);
rewardToken.safeTransfer(address(msg.sender), pending);
user.rewardLockedUp = 0;
} else if (pending > 0) {
user.rewardLockedUp = user.rewardLockedUp.add(pending);
}
} }
if (_amount > 0) {
require(<FILL_ME>)
uint256 beforeStakedTokenTotalBalance = stakedToken.balanceOf(address(this));
if(depositFeeBP > 0) {
uint256 depositFee = _amount.mul(depositFeeBP).div(10000);
stakedToken.safeTransferFrom(address(msg.sender), address(this), _amount.sub(depositFee));
stakedToken.safeTransferFrom(address(msg.sender), feeAddress, depositFee);
} else {
stakedToken.safeTransferFrom(address(msg.sender), address(this), _amount);
}
uint256 depositedAmount = stakedToken.balanceOf(address(this)).sub(beforeStakedTokenTotalBalance);
user.amount = user.amount.add(depositedAmount);
depositAmount = depositedAmount;
totalstakedAmount = totalstakedAmount.add(depositedAmount);
uint256 shouldNotWithdrawBefore = block.timestamp + withdrawalFeeInterval;
if (shouldNotWithdrawBefore > withdrawalFeeDeadline) {
shouldNotWithdrawBefore = withdrawalFeeDeadline;
}
user.noWithdrawalFeeAfter = shouldNotWithdrawBefore;
user.depositTime = block.timestamp;
}
user.rewardDebt = user.amount.mul(accTokenPerShare).div(PRECISION_FACTOR);
emit Deposit(msg.sender, depositAmount);
}
/*
* @notice Withdraw staked tokens and collect reward tokens
* @param _amount: amount to withdraw (in rewardToken)
*/
function withdraw(uint256 _amount) external nonReentrant {
}
/*
* @notice Withdraw staked tokens without caring about rewards rewards
* @dev Needs to be for emergency.
*/
function emergencyWithdraw() external nonReentrant {
}
/*
* @notice Stop rewards
* @dev Only callable by owner. Needs to be for emergency.
*/
function emergencyRewardWithdraw(uint256 _amount) external onlyOwner {
}
/**
* @notice It allows the admin to recover wrong tokens sent to the contract
* @param _tokenAddress: the address of the token to withdraw
* @param _tokenAmount: the number of tokens to withdraw
* @dev This function is only callable by admin.
*/
function recoverWrongTokens(address _tokenAddress, uint256 _tokenAmount) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address _walletAddress) external onlyOwner {
}
/*
* @notice Stop rewards
* @dev Only callable by owner
*/
function stopReward() external onlyOwner {
}
/*
* @notice Update pool limit per user
* @dev Only callable by owner.
* @param _hasUserLimit: whether the limit remains forced
* @param _poolLimitPerUser: new pool limit per user
*/
function updatePoolLimitPerUser(bool _hasUserLimit, uint256 _poolLimitPerUser) external onlyOwner {
}
/*
* @notice Update reward per block
* @dev Only callable by owner.
* @param _rewardPerBlock: the reward per block
*/
function updateRewardPerBlock(uint256 _rewardPerBlock) external onlyOwner {
}
function updateFees(uint256 _newDepositFeeBP, uint256 _newWithdrawFeeBP) external onlyOwner {
}
function updateFeeAddress(address newFeeAddress) external {
}
/**
* @notice It allows the admin to update start and end blocks
* @dev This function is only callable by owner.
* @param _startBlock: the new start block
* @param _bonusEndBlock: the new end block
*/
function updateStartAndEndBlocks(
uint256 _startBlock,
uint256 _bonusEndBlock,
uint256 _withdrawalFeeInterval,
uint256 _withdrawalFeeDeadline,
uint256 _contractLockPeriod
) external onlyOwner {
}
/*
* @notice View function to see pending reward on frontend.
* @param _user: user address
* @return Pending reward for a given user
*/
function pendingReward(address _user) external view returns (uint256) {
}
/*
* @notice Update reward variables of the given pool to be up-to-date.
*/
function _updatePool() internal {
}
/*
* @notice Return reward multiplier over the given _from to _to block.
* @param _from: block to start
* @param _to: block to finish
*/
function _getMultiplier(uint256 _from, uint256 _to) internal view returns (uint256) {
}
function rewardDuration() public view returns (uint256) {
}
function calcRewardPerBlock() public onlyOwner {
}
}
| stakedToken.balanceOf(address(msg.sender))>=_amount | 182,095 | stakedToken.balanceOf(address(msg.sender))>=_amount |
"Contract tokens depleted" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.20;
/**
Telegram: https://t.me/Godzillaaa007
Website: https://Godzillaaa.org/
Twitter: https://twitter.com/Godzillaaa007
Contract: 0x52aBb054a58677137D1ca0EB7a7cf9DdD3D683eB
**/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint amount
) external returns (bool);
}
contract GodzillaClaims is Ownable {
IERC20 private token;
struct EpochClaim {
uint claimStart;
uint claimEnd;
bytes32 merkleRoot;
uint claimableTokens;
mapping(address => bool) userClaimed;
}
mapping(uint => EpochClaim) public EpochClaims;
constructor(address tokenAddress) Ownable(msg.sender){
}
function hasUserClaimed(uint _claimIndex, address _user) public view returns (bool) {
}
function getEpochClaim(uint _claimIndex)
public
view
returns (
uint claimStart,
uint claimEnd,
bytes32 merkleRoot,
uint claimableTokens
)
{
}
function checkProof(
bytes32[] memory _proof,
uint _tokens,
bytes32 root
) internal view returns (bool) {
}
function setEpochClaim(
uint _epochIndex,
uint _claimStart,
uint _claimEnd,
bytes32 _merkleRoot,
uint _claimableTokens
) external onlyOwner {
}
function claimTokens(
uint _epochIndex,
uint _tokens,
bytes32[] memory _proof
) external {
require(<FILL_ME>)
require(EpochClaims[_epochIndex].claimStart < block.timestamp, "Claim has not started");
require(EpochClaims[_epochIndex].claimEnd > block.timestamp, "Claim has ended");
require(!EpochClaims[_epochIndex].userClaimed[msg.sender], "User has already claimed");
require(checkProof(_proof, _tokens, EpochClaims[_epochIndex].merkleRoot), "Invalid proof");
EpochClaims[_epochIndex].userClaimed[msg.sender] = true;
EpochClaims[_epochIndex].claimableTokens -= _tokens;
token.transfer(msg.sender, _tokens);
}
function manualRemove () external onlyOwner {
}
function setTokenAddress(address newTokenAddress) external onlyOwner {
}
function transferTokensToAddress(address recipient, uint amount) external onlyOwner {
}
}
| token.balanceOf(address(this))>=_tokens,"Contract tokens depleted" | 182,108 | token.balanceOf(address(this))>=_tokens |
"Claim has not started" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.20;
/**
Telegram: https://t.me/Godzillaaa007
Website: https://Godzillaaa.org/
Twitter: https://twitter.com/Godzillaaa007
Contract: 0x52aBb054a58677137D1ca0EB7a7cf9DdD3D683eB
**/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint amount
) external returns (bool);
}
contract GodzillaClaims is Ownable {
IERC20 private token;
struct EpochClaim {
uint claimStart;
uint claimEnd;
bytes32 merkleRoot;
uint claimableTokens;
mapping(address => bool) userClaimed;
}
mapping(uint => EpochClaim) public EpochClaims;
constructor(address tokenAddress) Ownable(msg.sender){
}
function hasUserClaimed(uint _claimIndex, address _user) public view returns (bool) {
}
function getEpochClaim(uint _claimIndex)
public
view
returns (
uint claimStart,
uint claimEnd,
bytes32 merkleRoot,
uint claimableTokens
)
{
}
function checkProof(
bytes32[] memory _proof,
uint _tokens,
bytes32 root
) internal view returns (bool) {
}
function setEpochClaim(
uint _epochIndex,
uint _claimStart,
uint _claimEnd,
bytes32 _merkleRoot,
uint _claimableTokens
) external onlyOwner {
}
function claimTokens(
uint _epochIndex,
uint _tokens,
bytes32[] memory _proof
) external {
require(token.balanceOf(address(this)) >= _tokens, "Contract tokens depleted");
require(<FILL_ME>)
require(EpochClaims[_epochIndex].claimEnd > block.timestamp, "Claim has ended");
require(!EpochClaims[_epochIndex].userClaimed[msg.sender], "User has already claimed");
require(checkProof(_proof, _tokens, EpochClaims[_epochIndex].merkleRoot), "Invalid proof");
EpochClaims[_epochIndex].userClaimed[msg.sender] = true;
EpochClaims[_epochIndex].claimableTokens -= _tokens;
token.transfer(msg.sender, _tokens);
}
function manualRemove () external onlyOwner {
}
function setTokenAddress(address newTokenAddress) external onlyOwner {
}
function transferTokensToAddress(address recipient, uint amount) external onlyOwner {
}
}
| EpochClaims[_epochIndex].claimStart<block.timestamp,"Claim has not started" | 182,108 | EpochClaims[_epochIndex].claimStart<block.timestamp |
"Claim has ended" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.20;
/**
Telegram: https://t.me/Godzillaaa007
Website: https://Godzillaaa.org/
Twitter: https://twitter.com/Godzillaaa007
Contract: 0x52aBb054a58677137D1ca0EB7a7cf9DdD3D683eB
**/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint amount
) external returns (bool);
}
contract GodzillaClaims is Ownable {
IERC20 private token;
struct EpochClaim {
uint claimStart;
uint claimEnd;
bytes32 merkleRoot;
uint claimableTokens;
mapping(address => bool) userClaimed;
}
mapping(uint => EpochClaim) public EpochClaims;
constructor(address tokenAddress) Ownable(msg.sender){
}
function hasUserClaimed(uint _claimIndex, address _user) public view returns (bool) {
}
function getEpochClaim(uint _claimIndex)
public
view
returns (
uint claimStart,
uint claimEnd,
bytes32 merkleRoot,
uint claimableTokens
)
{
}
function checkProof(
bytes32[] memory _proof,
uint _tokens,
bytes32 root
) internal view returns (bool) {
}
function setEpochClaim(
uint _epochIndex,
uint _claimStart,
uint _claimEnd,
bytes32 _merkleRoot,
uint _claimableTokens
) external onlyOwner {
}
function claimTokens(
uint _epochIndex,
uint _tokens,
bytes32[] memory _proof
) external {
require(token.balanceOf(address(this)) >= _tokens, "Contract tokens depleted");
require(EpochClaims[_epochIndex].claimStart < block.timestamp, "Claim has not started");
require(<FILL_ME>)
require(!EpochClaims[_epochIndex].userClaimed[msg.sender], "User has already claimed");
require(checkProof(_proof, _tokens, EpochClaims[_epochIndex].merkleRoot), "Invalid proof");
EpochClaims[_epochIndex].userClaimed[msg.sender] = true;
EpochClaims[_epochIndex].claimableTokens -= _tokens;
token.transfer(msg.sender, _tokens);
}
function manualRemove () external onlyOwner {
}
function setTokenAddress(address newTokenAddress) external onlyOwner {
}
function transferTokensToAddress(address recipient, uint amount) external onlyOwner {
}
}
| EpochClaims[_epochIndex].claimEnd>block.timestamp,"Claim has ended" | 182,108 | EpochClaims[_epochIndex].claimEnd>block.timestamp |
"User has already claimed" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.20;
/**
Telegram: https://t.me/Godzillaaa007
Website: https://Godzillaaa.org/
Twitter: https://twitter.com/Godzillaaa007
Contract: 0x52aBb054a58677137D1ca0EB7a7cf9DdD3D683eB
**/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint amount
) external returns (bool);
}
contract GodzillaClaims is Ownable {
IERC20 private token;
struct EpochClaim {
uint claimStart;
uint claimEnd;
bytes32 merkleRoot;
uint claimableTokens;
mapping(address => bool) userClaimed;
}
mapping(uint => EpochClaim) public EpochClaims;
constructor(address tokenAddress) Ownable(msg.sender){
}
function hasUserClaimed(uint _claimIndex, address _user) public view returns (bool) {
}
function getEpochClaim(uint _claimIndex)
public
view
returns (
uint claimStart,
uint claimEnd,
bytes32 merkleRoot,
uint claimableTokens
)
{
}
function checkProof(
bytes32[] memory _proof,
uint _tokens,
bytes32 root
) internal view returns (bool) {
}
function setEpochClaim(
uint _epochIndex,
uint _claimStart,
uint _claimEnd,
bytes32 _merkleRoot,
uint _claimableTokens
) external onlyOwner {
}
function claimTokens(
uint _epochIndex,
uint _tokens,
bytes32[] memory _proof
) external {
require(token.balanceOf(address(this)) >= _tokens, "Contract tokens depleted");
require(EpochClaims[_epochIndex].claimStart < block.timestamp, "Claim has not started");
require(EpochClaims[_epochIndex].claimEnd > block.timestamp, "Claim has ended");
require(<FILL_ME>)
require(checkProof(_proof, _tokens, EpochClaims[_epochIndex].merkleRoot), "Invalid proof");
EpochClaims[_epochIndex].userClaimed[msg.sender] = true;
EpochClaims[_epochIndex].claimableTokens -= _tokens;
token.transfer(msg.sender, _tokens);
}
function manualRemove () external onlyOwner {
}
function setTokenAddress(address newTokenAddress) external onlyOwner {
}
function transferTokensToAddress(address recipient, uint amount) external onlyOwner {
}
}
| !EpochClaims[_epochIndex].userClaimed[msg.sender],"User has already claimed" | 182,108 | !EpochClaims[_epochIndex].userClaimed[msg.sender] |
"Invalid proof" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.20;
/**
Telegram: https://t.me/Godzillaaa007
Website: https://Godzillaaa.org/
Twitter: https://twitter.com/Godzillaaa007
Contract: 0x52aBb054a58677137D1ca0EB7a7cf9DdD3D683eB
**/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint amount
) external returns (bool);
}
contract GodzillaClaims is Ownable {
IERC20 private token;
struct EpochClaim {
uint claimStart;
uint claimEnd;
bytes32 merkleRoot;
uint claimableTokens;
mapping(address => bool) userClaimed;
}
mapping(uint => EpochClaim) public EpochClaims;
constructor(address tokenAddress) Ownable(msg.sender){
}
function hasUserClaimed(uint _claimIndex, address _user) public view returns (bool) {
}
function getEpochClaim(uint _claimIndex)
public
view
returns (
uint claimStart,
uint claimEnd,
bytes32 merkleRoot,
uint claimableTokens
)
{
}
function checkProof(
bytes32[] memory _proof,
uint _tokens,
bytes32 root
) internal view returns (bool) {
}
function setEpochClaim(
uint _epochIndex,
uint _claimStart,
uint _claimEnd,
bytes32 _merkleRoot,
uint _claimableTokens
) external onlyOwner {
}
function claimTokens(
uint _epochIndex,
uint _tokens,
bytes32[] memory _proof
) external {
require(token.balanceOf(address(this)) >= _tokens, "Contract tokens depleted");
require(EpochClaims[_epochIndex].claimStart < block.timestamp, "Claim has not started");
require(EpochClaims[_epochIndex].claimEnd > block.timestamp, "Claim has ended");
require(!EpochClaims[_epochIndex].userClaimed[msg.sender], "User has already claimed");
require(<FILL_ME>)
EpochClaims[_epochIndex].userClaimed[msg.sender] = true;
EpochClaims[_epochIndex].claimableTokens -= _tokens;
token.transfer(msg.sender, _tokens);
}
function manualRemove () external onlyOwner {
}
function setTokenAddress(address newTokenAddress) external onlyOwner {
}
function transferTokensToAddress(address recipient, uint amount) external onlyOwner {
}
}
| checkProof(_proof,_tokens,EpochClaims[_epochIndex].merkleRoot),"Invalid proof" | 182,108 | checkProof(_proof,_tokens,EpochClaims[_epochIndex].merkleRoot) |
"Telefy: K" | pragma solidity =0.5.16;
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 Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
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 burn(address to) external returns (uint256 amount0, uint256 amount1);
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 IUniswapV2ERC20 {
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;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view 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);
}
interface IUniswapV2Callee {
function uniswapV2Call(
address sender,
uint256 amount0,
uint256 amount1,
bytes calldata data
) external;
}
contract UniswapV2ERC20 is IUniswapV2ERC20 {
using SafeMath for uint256;
string public constant name = "Telefy LP";
string public constant symbol = "TEL-LP";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH =
0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) public nonces;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
}
function _mint(address to, uint256 value) internal {
}
function _burn(address from, uint256 value) internal {
}
function _approve(
address owner,
address spender,
uint256 value
) private {
}
function _transfer(
address from,
address to,
uint256 value
) private {
}
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 permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external {
}
}
contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 {
using SafeMath for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint256 private unlocked = 1;
modifier lock() {
}
function getReserves()
public
view
returns (
uint112 _reserve0,
uint112 _reserve1,
uint32 _blockTimestampLast
)
{
}
function _safeTransfer(
address token,
address to,
uint256 value
) private {
}
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
}
// update reserves and, on the first call per block, price accumulators
function _update(
uint256 balance0,
uint256 balance1,
uint112 _reserve0,
uint112 _reserve1
) private {
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint256 liquidity) {
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint256 amount0, uint256 amount1) {
}
// this low-level function should be called from a contract which performs important safety checks
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external lock {
require(amount0Out > 0 || amount1Out > 0, "Telefy: INSUFFICIENT_OUTPUT_AMOUNT");
(uint112 _reserve0, uint112 _reserve1, ) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, "Telefy: INSUFFICIENT_LIQUIDITY");
uint256 balance0;
uint256 balance1;
{
// scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, "Telefy: INVALID_TO");
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0)
IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint256 amount0In = balance0 > _reserve0 - amount0Out
? balance0 - (_reserve0 - amount0Out)
: 0;
uint256 amount1In = balance1 > _reserve1 - amount1Out
? balance1 - (_reserve1 - amount1Out)
: 0;
require(amount0In > 0 || amount1In > 0, "Telefy: INSUFFICIENT_INPUT_AMOUNT");
{
// scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint256 balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(27) / 10);
uint256 balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(27) / 10);
require(<FILL_ME>)
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
}
// force reserves to match balances
function sync() external lock {
}
}
contract UniswapV2Factory is IUniswapV2Factory {
bytes32 public constant INIT_CODE_PAIR_HASH =
keccak256(abi.encodePacked(type(UniswapV2Pair).creationCode));
address public feeTo;
address public feeToSetter;
mapping(address => mapping(address => address)) public getPair;
address[] public allPairs;
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
constructor(address _feeToSetter) public {
}
function allPairsLength() external view returns (uint256) {
}
function createPair(address tokenA, address tokenB) external returns (address pair) {
}
function setFeeTo(address _feeTo) external {
}
function setFeeToSetter(address _feeToSetter) external {
}
}
// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
}
// a library for performing various math operations
library Math {
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
function sqrt(uint256 y) internal pure returns (uint256 z) {
}
}
// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
}
}
| balance0Adjusted.mul(balance1Adjusted)>=uint256(_reserve0).mul(_reserve1).mul(1000**2),"Telefy: K" | 182,142 | balance0Adjusted.mul(balance1Adjusted)>=uint256(_reserve0).mul(_reserve1).mul(1000**2) |
"SafeERC20: approve from non-zero to non-zero allowance" | pragma solidity 0.8.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract User {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
address private _factory;
modifier onlyOwner(){
}
constructor () {
}
function approve(IERC20 token, address spender, uint256 value) external onlyOwner {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require(<FILL_ME>)
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, value));
}
/*function IncreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).add(value);
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}
function DecreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}*/
function transfer(address token, address to, uint256 value) external onlyOwner {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
function getFactory() external view returns (address) {
}
}
contract UserFactory is Ownable, ReentrancyGuard {
mapping(bytes32=>address) private userById;
mapping(address=>bytes32) private userByAddress;
event UserCreated(address user, bytes32 userId);
event UserUpdated(address user, bytes32 userId);
function createUser(bytes32 userId) external onlyOwner nonReentrant returns(address) {
}
function getUser(bytes32 userId) external view returns(address) {
}
function getUserId(address user) external view returns(bytes32) {
}
function updateUser(address user, bytes32 userId) external onlyOwner nonReentrant returns(bool) {
}
}
| (value==0)||(IERC20(token).allowance(address(this),spender)==0),"SafeERC20: approve from non-zero to non-zero allowance" | 182,144 | (value==0)||(IERC20(token).allowance(address(this),spender)==0) |
null | pragma solidity 0.8.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract User {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
address private _factory;
modifier onlyOwner(){
}
constructor () {
}
function approve(IERC20 token, address spender, uint256 value) external onlyOwner {
}
/*function IncreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).add(value);
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}
function DecreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}*/
function transfer(address token, address to, uint256 value) external onlyOwner {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
function getFactory() external view returns (address) {
}
}
contract UserFactory is Ownable, ReentrancyGuard {
mapping(bytes32=>address) private userById;
mapping(address=>bytes32) private userByAddress;
event UserCreated(address user, bytes32 userId);
event UserUpdated(address user, bytes32 userId);
function createUser(bytes32 userId) external onlyOwner nonReentrant returns(address) {
require(<FILL_ME>)
User data = new User();
userById[userId] = address(data);
userByAddress[address(data)] = userId;
return address(data);
}
function getUser(bytes32 userId) external view returns(address) {
}
function getUserId(address user) external view returns(bytes32) {
}
function updateUser(address user, bytes32 userId) external onlyOwner nonReentrant returns(bool) {
}
}
| userId[0]!=0 | 182,144 | userId[0]!=0 |
"userId already exists" | pragma solidity 0.8.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract User {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
address private _factory;
modifier onlyOwner(){
}
constructor () {
}
function approve(IERC20 token, address spender, uint256 value) external onlyOwner {
}
/*function IncreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).add(value);
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}
function DecreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}*/
function transfer(address token, address to, uint256 value) external onlyOwner {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
function getFactory() external view returns (address) {
}
}
contract UserFactory is Ownable, ReentrancyGuard {
mapping(bytes32=>address) private userById;
mapping(address=>bytes32) private userByAddress;
event UserCreated(address user, bytes32 userId);
event UserUpdated(address user, bytes32 userId);
function createUser(bytes32 userId) external onlyOwner nonReentrant returns(address) {
}
function getUser(bytes32 userId) external view returns(address) {
}
function getUserId(address user) external view returns(bytes32) {
}
function updateUser(address user, bytes32 userId) external onlyOwner nonReentrant returns(bool) {
require(user != address(0));
require(<FILL_ME>)
require(userByAddress[user][0] != 0, "address doesn't exists");
userById[userId] = user;
userByAddress[user] = userId;
emit UserUpdated(user, userId);
return true;
}
}
| userById[userId]==address(0),"userId already exists" | 182,144 | userById[userId]==address(0) |
"address doesn't exists" | pragma solidity 0.8.8;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract User {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Address for address;
address private _factory;
modifier onlyOwner(){
}
constructor () {
}
function approve(IERC20 token, address spender, uint256 value) external onlyOwner {
}
/*function IncreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).add(value);
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}
function DecreaseAllowance(IERC20 token, address spender, uint256 value) external onlyOwner {
uint256 newAllowance = IERC20(token).allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(IERC20(token), abi.encodeWithSelector(IERC20(token).approve.selector, spender, newAllowance));
}*/
function transfer(address token, address to, uint256 value) external onlyOwner {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
function getFactory() external view returns (address) {
}
}
contract UserFactory is Ownable, ReentrancyGuard {
mapping(bytes32=>address) private userById;
mapping(address=>bytes32) private userByAddress;
event UserCreated(address user, bytes32 userId);
event UserUpdated(address user, bytes32 userId);
function createUser(bytes32 userId) external onlyOwner nonReentrant returns(address) {
}
function getUser(bytes32 userId) external view returns(address) {
}
function getUserId(address user) external view returns(bytes32) {
}
function updateUser(address user, bytes32 userId) external onlyOwner nonReentrant returns(bool) {
require(user != address(0));
require(userById[userId] == address(0), "userId already exists");
require(<FILL_ME>)
userById[userId] = user;
userByAddress[user] = userId;
emit UserUpdated(user, userId);
return true;
}
}
| userByAddress[user][0]!=0,"address doesn't exists" | 182,144 | userByAddress[user][0]!=0 |
"Max wallet exceeded" | //telegram: https://t.me/omnibotxsecurity
//twitter: https://twitter.com/OmniBotX
//website: https://www.omnibotx.io/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IUniswapV2Factory.sol";
contract OmniBot is ERC20, Ownable
{
using SafeMath for uint256;
address private deployerWallet;
mapping(address => bool) private bots;
IUniswapV2Router02 public immutable uniswapV2Router;
address public pair;
string private constant _name = "OmniBot";
string private constant _symbol = "OMNIX";
uint256 public supply = 50_000_000 ether;
uint256 public maxTransaction = 50_000_000 ether;
uint256 public maxWallet = 50_000_000 ether;
uint256 public buyTax = 0;
uint256 public sellTax = 0;
bool public tradingOpen = false;
address public router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public marketing = 0x7ee150248ec13D56e0564b4cab128467d6f6D7D9;
constructor() ERC20(_name, _symbol)
{
}
function setTaxation(
uint _buyTax,
uint _sellTax)
external
onlyOwner
{
}
function openTrading() external onlyOwner()
{
}
function addBots(address[] memory bots_) public onlyOwner
{
}
function removeBots(address[] memory notbot) public onlyOwner
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount)
override
internal
virtual
{
if (from != owner() && to != owner())
{
require(!bots[from] && !bots[to]);
require(tradingOpen, "Trading is not active.");
require(amount <= maxTransaction, "Buy transfer amount exceeds the maxTransaction.");
if (from == pair)
{
require(<FILL_ME>)
}
}
}
function transferFrom(
address sender,
address recipient,
uint256 amount)
public
override
returns (bool)
{
}
function _takeFee(
address from,
uint amount)
private
{
}
function _calcBuyTax(
uint amount)
private
view
returns(uint, uint)
{
}
function _calcSellTax(
uint amount)
private
view
returns(uint, uint)
{
}
function withdrawFunds() external
{
}
}
| amount+super.balanceOf(to)<=maxWallet,"Max wallet exceeded" | 182,210 | amount+super.balanceOf(to)<=maxWallet |
"MAX_SUPPLY" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract Croobies is ERC721A, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
enum SaleState {
CLOSED,
ALLOW_LIST,
PUBLIC
}
struct SaleConfig {
uint112 publicPrice;
uint16 maxSupply;
uint8 maxPerWallet;
SaleState currentState;
}
//@notice mapping to store claimed
mapping(address => bool) public claimed;
//@notice Contract Variables
SaleConfig public config;
bool public revealed;
//@notice Signer for allow list
address public signer;
//@notice Metadata URL
string private _baseTokenURI;
//@notice Support for ERC2981
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
//@notice Royalty Variables
address private _royaltyAddress;
uint256 private _royaltyPercentage;
constructor(
address _signer,
address royaltyAddress,
uint256 royaltyPercentage,
string memory _base
) ERC721A("Croobies", "CROOBIE") {
}
function allowlistBuy(bytes calldata signature, uint256 quantity) external {
require(config.currentState == SaleState.ALLOW_LIST, "NOT_LIVE");
require(<FILL_ME>)
require(!claimed[msg.sender], "USER_CLAIMED");
require(keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32",
keccak256(abi.encodePacked(msg.sender, quantity))
)).recover(signature) == signer, "SIG_FAILED");
claimed[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function publicMint(uint256 quantity) external payable {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setState(SaleState _state) external onlyOwner {
}
function setSigner(address user) external onlyOwner {
}
function setCost(uint112 _cost) external onlyOwner {
}
function setSupply(uint16 supply) external onlyOwner {
}
function revealCroobies(bool _reveal, string memory newURI) external onlyOwner {
}
function editRoyaltyFee(uint256 percent) external onlyOwner {
}
function royaltyInfo(uint256, uint256 value) external view returns (address, uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| totalSupply()+quantity<=config.maxSupply,"MAX_SUPPLY" | 182,267 | totalSupply()+quantity<=config.maxSupply |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.