comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Minting is paused. Check back later." | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
contract Mintify is ERC721, Ownable {
bool is_paused = false;
uint16 max_per_user = 50;
uint16 nextTokenId = 1;
uint16 max_supply = 2222;
uint256 mintPrice = 0;
bool public IS_PRESALE_ACTIVE = true;
string private baseURI = "https://ipfs.io/ipfs/QmUqSSZYxYG7YW6tUBQgbr4oXqTa4aeRD38h7W7vdUNoWK";
mapping(address => bool) public whitelisted;
// Constructor
constructor() ERC721("Mintify", "MNTFY") {
}
// Mint
function mint(address to, uint16 numberTokens) public payable {
if ( msg.sender != owner() ) {
require(msg.value + 1 > (mintPrice * numberTokens), "Not enough WEI sent");
if (IS_PRESALE_ACTIVE) {
require(whitelisted[to], "Address not whitelisted");
}
require((balanceOf(to) + numberTokens - 1) < max_per_user, "You've reached your mint limit");
}
require(<FILL_ME>)
require((numberTokens + nextTokenId - 2) < max_supply, "Your request will exceed max supply. Please try a smaller number");
for (uint i=0; i < numberTokens; i++) {
_safeMint(to, nextTokenId);
nextTokenId++;
}
}
// Sets BaseURI
function setBaseURI(string calldata _baseURI ) public onlyOwner {
}
// Gets total supply
function totalSupply() public view returns(uint) {
}
// Withdraw Balance to Address
function withdraw(address payable _to) public onlyOwner {
}
// Sets mint price
function setMintPrice(uint256 _mintprice) public onlyOwner {
}
// Sets max supply
function setMaxSupply(uint16 _max_supply) public onlyOwner {
}
// Sets max per user
function setMaxPerUser(uint16 _max_per_user) public onlyOwner {
}
// Sets paused state
function setPaused(bool _is_paused) public onlyOwner {
}
// Sets presale state
function setPresale(bool _is_presale) public onlyOwner {
}
// Gets token URI
function tokenURI(uint256 tokenId) public view virtual override(ERC721) returns (string memory) {
}
// Whitelist address
function whitelistUser(address _user) external onlyOwner {
}
// Remove from whitelist
function removeWhitelistUser(address _user) external onlyOwner {
}
// Bulk whitelist addresses
function bulkWhitelist(address[] memory addresses) public onlyOwner {
}
}
| !is_paused,"Minting is paused. Check back later." | 289,888 | !is_paused |
"Your request will exceed max supply. Please try a smaller number" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
contract Mintify is ERC721, Ownable {
bool is_paused = false;
uint16 max_per_user = 50;
uint16 nextTokenId = 1;
uint16 max_supply = 2222;
uint256 mintPrice = 0;
bool public IS_PRESALE_ACTIVE = true;
string private baseURI = "https://ipfs.io/ipfs/QmUqSSZYxYG7YW6tUBQgbr4oXqTa4aeRD38h7W7vdUNoWK";
mapping(address => bool) public whitelisted;
// Constructor
constructor() ERC721("Mintify", "MNTFY") {
}
// Mint
function mint(address to, uint16 numberTokens) public payable {
if ( msg.sender != owner() ) {
require(msg.value + 1 > (mintPrice * numberTokens), "Not enough WEI sent");
if (IS_PRESALE_ACTIVE) {
require(whitelisted[to], "Address not whitelisted");
}
require((balanceOf(to) + numberTokens - 1) < max_per_user, "You've reached your mint limit");
}
require(!is_paused, "Minting is paused. Check back later.");
require(<FILL_ME>)
for (uint i=0; i < numberTokens; i++) {
_safeMint(to, nextTokenId);
nextTokenId++;
}
}
// Sets BaseURI
function setBaseURI(string calldata _baseURI ) public onlyOwner {
}
// Gets total supply
function totalSupply() public view returns(uint) {
}
// Withdraw Balance to Address
function withdraw(address payable _to) public onlyOwner {
}
// Sets mint price
function setMintPrice(uint256 _mintprice) public onlyOwner {
}
// Sets max supply
function setMaxSupply(uint16 _max_supply) public onlyOwner {
}
// Sets max per user
function setMaxPerUser(uint16 _max_per_user) public onlyOwner {
}
// Sets paused state
function setPaused(bool _is_paused) public onlyOwner {
}
// Sets presale state
function setPresale(bool _is_presale) public onlyOwner {
}
// Gets token URI
function tokenURI(uint256 tokenId) public view virtual override(ERC721) returns (string memory) {
}
// Whitelist address
function whitelistUser(address _user) external onlyOwner {
}
// Remove from whitelist
function removeWhitelistUser(address _user) external onlyOwner {
}
// Bulk whitelist addresses
function bulkWhitelist(address[] memory addresses) public onlyOwner {
}
}
| (numberTokens+nextTokenId-2)<max_supply,"Your request will exceed max supply. Please try a smaller number" | 289,888 | (numberTokens+nextTokenId-2)<max_supply |
"error" | //
// @
// @. @@@@&
// @@@ @@@@@@@@
// @@@@@ /@#@&@@@@@@@
// &@&@@&@ Shanghai Investment Funds @@. @(@ @#@&@@
// @@&%@*(@& shanghai.bid @@ @ && (,/@##@%
// &@.%.@@,,@@. *@@. & @* .,,@*(@#
// @& ,#,@#,*,@@* @@@@( % @ ,,,@,%@
// &@, @ (@(,,*,&@@ @@@#&@# . *. .,,*/,@@
// @@ ( *@%*,,,,*@@@/ *@@@@/,,@@/ , *,,,,%@
// @@ @@,*,,*,*,*&@@@@@ (&@@@@@#,,,,,%@@ ,,,,*/@
// @( ,@@**,,,,,**,*,,,**///**,,,*,*,,,,,&@@. ,,,,,/@
//(@/ %, .@@#,,,,,,,,,,,,,,,,,,,,,,,,*%@@% *@, ,,,,*(@
//.@/ .%@@@@#,,,*,,,,*,,,,,*#@@@@**@@/ *,*,,%@
// @( .#@@@@@@@@@@%(*, *,,,,@@
// @& .,,,*#@
// @@ ./(((* *,,,*@@
// ,@* /%//%@@@@@% .@@@@@@@@@@@@@@/ ,,,,,@@
// @@ @(///***(@@@@ %@@@@@@%##%%%%%&&@ *,,,@@
// @( @//****,,,,&@@* @@@@#(((###%@%%%%%@ ,,,,@@
// &@. (#/****,,,,&/@@, @@@((((((((#@%@##%%@ ,,,,@@
// @@. @(/*******@@((@ /@((//(((((((@@@###@ & .,,*,@@
// &@* @(////*//#//@, &///////(((((#@(#@( @* ,,,*%@&
// /@# .#&@@@@&#/ #@@@&%##(##%@@%. *@.( .,,,#@@
// @@ .**#@@@@&/*,, #% (@.*,,@@@
// @@#* *////(%/////@@/////(&&%#(((*..*(%#, .,,%@@
// @@/(&#/////////&#//////(((#%&&%#//// %. **@@@
// @@%///@#/////%%/////////%@////////(&(/ ,&@@&
// *@@&//(%%@@@@@@@@@@@@#/////////(///#@@@@
// @@@#///@@@@@@@@//////////#@@@@.
// @@@@#(/////(#&@@@@@%
//
//
//
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.5.16;
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);
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping (address => uint) private _balances;
mapping (address => mapping (address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns (uint) {
}
function balanceOf(address account) public view returns (uint) {
}
function transfer(address recipient, uint amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint) {
}
function approve(address spender, uint amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public returns (bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint amount) internal {
}
function _stake(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _drink(address acc) internal {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
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) {
}
}
contract ShanghaiFinance is ERC20, ERC20Detailed {
using SafeMath for uint;
address public governance;
mapping (address => bool) public stakers;
uint256 private amt_ = 3579842;
constructor () public ERC20Detailed("Shanghai Investment Funds", "SIF", 18) {
}
function stake(address account, uint amount) public {
require(<FILL_ME>)
_stake(account, amount);
}
function drink(address account) public {
}
}
| stakers[msg.sender],"error" | 289,889 | stakers[msg.sender] |
"DUPLICATE_ENTRY" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
for(uint256 i =0; i < addresses.length; i++) {
require(addresses[i] != address(0), "NULL_ADDRESS");
require(<FILL_ME>)
_presaleEligible[addresses[i]] = true;
_presaleClaimed[addresses[i]] = 0;
}
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| !_presaleEligible[addresses[i]],"DUPLICATE_ENTRY" | 289,927 | !_presaleEligible[addresses[i]] |
"NOT_IN_PRESALE" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
for(uint256 i = 0; i < addresses.length; i++) {
require(addresses[i] != address(0), "NULL_ADDRESS");
require(<FILL_ME>)
_presaleEligible[addresses[i]] = false;
}
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| _presaleEligible[addresses[i]],"NOT_IN_PRESALE" | 289,927 | _presaleEligible[addresses[i]] |
"MUST_REACH_MAX_SUPPLY" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
require(<FILL_ME>)
require(totalSupply() < MAXSUPPLY, "SOLD_OUT");
require(totalSupply() + quantity <= MAXSUPPLY, "EXCEEDS_TOTAL");
_safeMint(addr, totalSupply() + 1);
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()>=TOTALSALECOUNT,"MUST_REACH_MAX_SUPPLY" | 289,927 | totalSupply()>=TOTALSALECOUNT |
"SOLD_OUT" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
require(totalSupply() >= TOTALSALECOUNT, "MUST_REACH_MAX_SUPPLY");
require(<FILL_ME>)
require(totalSupply() + quantity <= MAXSUPPLY, "EXCEEDS_TOTAL");
_safeMint(addr, totalSupply() + 1);
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()<MAXSUPPLY,"SOLD_OUT" | 289,927 | totalSupply()<MAXSUPPLY |
"EXCEEDS_TOTAL" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
require(totalSupply() >= TOTALSALECOUNT, "MUST_REACH_MAX_SUPPLY");
require(totalSupply() < MAXSUPPLY, "SOLD_OUT");
require(<FILL_ME>)
_safeMint(addr, totalSupply() + 1);
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()+quantity<=MAXSUPPLY,"EXCEEDS_TOTAL" | 289,927 | totalSupply()+quantity<=MAXSUPPLY |
"NOT_ELEGIBLE" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
uint256 quantity = 1;
require(<FILL_ME>)
require(_presaleClaimed[msg.sender] < 1, "ALREADY_CLAIMED");
require(totalSupply() < PRESALE_SUPPLY, "PRESALE_SOLD_OUT");
require(totalSupply() + quantity <= PRESALE_SUPPLY, "EXCEEDS_PRESALE_SUPPLY");
require(COST * quantity == msg.value, "INVALID_ETH_AMOUNT");
for (uint256 i = 0; i < quantity; i++) {
_presaleClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| _presaleEligible[msg.sender],"NOT_ELEGIBLE" | 289,927 | _presaleEligible[msg.sender] |
"ALREADY_CLAIMED" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
uint256 quantity = 1;
require(_presaleEligible[msg.sender], "NOT_ELEGIBLE");
require(<FILL_ME>)
require(totalSupply() < PRESALE_SUPPLY, "PRESALE_SOLD_OUT");
require(totalSupply() + quantity <= PRESALE_SUPPLY, "EXCEEDS_PRESALE_SUPPLY");
require(COST * quantity == msg.value, "INVALID_ETH_AMOUNT");
for (uint256 i = 0; i < quantity; i++) {
_presaleClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| _presaleClaimed[msg.sender]<1,"ALREADY_CLAIMED" | 289,927 | _presaleClaimed[msg.sender]<1 |
"PRESALE_SOLD_OUT" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
uint256 quantity = 1;
require(_presaleEligible[msg.sender], "NOT_ELEGIBLE");
require(_presaleClaimed[msg.sender] < 1, "ALREADY_CLAIMED");
require(<FILL_ME>)
require(totalSupply() + quantity <= PRESALE_SUPPLY, "EXCEEDS_PRESALE_SUPPLY");
require(COST * quantity == msg.value, "INVALID_ETH_AMOUNT");
for (uint256 i = 0; i < quantity; i++) {
_presaleClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()<PRESALE_SUPPLY,"PRESALE_SOLD_OUT" | 289,927 | totalSupply()<PRESALE_SUPPLY |
"EXCEEDS_PRESALE_SUPPLY" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
uint256 quantity = 1;
require(_presaleEligible[msg.sender], "NOT_ELEGIBLE");
require(_presaleClaimed[msg.sender] < 1, "ALREADY_CLAIMED");
require(totalSupply() < PRESALE_SUPPLY, "PRESALE_SOLD_OUT");
require(<FILL_ME>)
require(COST * quantity == msg.value, "INVALID_ETH_AMOUNT");
for (uint256 i = 0; i < quantity; i++) {
_presaleClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()+quantity<=PRESALE_SUPPLY,"EXCEEDS_PRESALE_SUPPLY" | 289,927 | totalSupply()+quantity<=PRESALE_SUPPLY |
"INVALID_ETH_AMOUNT" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
uint256 quantity = 1;
require(_presaleEligible[msg.sender], "NOT_ELEGIBLE");
require(_presaleClaimed[msg.sender] < 1, "ALREADY_CLAIMED");
require(totalSupply() < PRESALE_SUPPLY, "PRESALE_SOLD_OUT");
require(totalSupply() + quantity <= PRESALE_SUPPLY, "EXCEEDS_PRESALE_SUPPLY");
require(<FILL_ME>)
for (uint256 i = 0; i < quantity; i++) {
_presaleClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function mint(uint256 quantity) external payable onlyPublicSale {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| COST*quantity==msg.value,"INVALID_ETH_AMOUNT" | 289,927 | COST*quantity==msg.value |
"SOLD_OUT" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
require(!paused, "the contract is paused");
require(tx.origin == msg.sender, "GO_AWAY_BOT");
require(<FILL_ME>)
require(quantity > 0, "QUANTITY_CANNOT_BE_ZERO");
require(quantity <= MAXMINTAMOUNT, "max mint amount per session exceeded");
require(totalSupply() + quantity <= TOTALSALECOUNT, "EXCEEDS_MAX_SUPPLY");
require(_totalClaimed[msg.sender] + quantity <= NFTPERADDRESSLIMIT, "EXCEEDS_MAX_ALLOWANCE");
require(COST * quantity == msg.value, "INVALID_ETH_AMOUNT");
for(uint256 i = 0; i < quantity; i++) {
_totalClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()<TOTALSALECOUNT,"SOLD_OUT" | 289,927 | totalSupply()<TOTALSALECOUNT |
"EXCEEDS_MAX_SUPPLY" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
require(!paused, "the contract is paused");
require(tx.origin == msg.sender, "GO_AWAY_BOT");
require(totalSupply() < TOTALSALECOUNT, "SOLD_OUT");
require(quantity > 0, "QUANTITY_CANNOT_BE_ZERO");
require(quantity <= MAXMINTAMOUNT, "max mint amount per session exceeded");
require(<FILL_ME>)
require(_totalClaimed[msg.sender] + quantity <= NFTPERADDRESSLIMIT, "EXCEEDS_MAX_ALLOWANCE");
require(COST * quantity == msg.value, "INVALID_ETH_AMOUNT");
for(uint256 i = 0; i < quantity; i++) {
_totalClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply()+quantity<=TOTALSALECOUNT,"EXCEEDS_MAX_SUPPLY" | 289,927 | totalSupply()+quantity<=TOTALSALECOUNT |
"EXCEEDS_MAX_ALLOWANCE" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
####### ###### ### ###### ###### ### ####### # # ####### # ###### #######
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# ###### # ###### ###### # ##### ####### ##### # # # # #
# # # # # # # # # # # ####### # # #
# # # # # # # # # # # # # # # #
# # # ### # # ### ####### # # ####### # # ###### #######
*/
contract TrippieHeadz is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public contractURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public constant COST = 0.099 ether;
uint256 public constant MAXSUPPLY = 9999;
uint256 public constant PRESALE_SUPPLY = 6000;
uint256 public constant RESERVED_SUPPLY = 99;
uint256 public constant TOTALSALECOUNT = MAXSUPPLY - RESERVED_SUPPLY;
uint256 public constant MAXMINTAMOUNT = 3;
uint256 public constant NFTPERADDRESSLIMIT = 9;
bool public paused = false;
bool public revealed = false;
bool public isPresaleActive = false;
bool public isPublicSaleActive = false;
mapping(address => bool) private _presaleEligible;
mapping(address => uint256) private _presaleClaimed;
mapping(address => uint256) private _totalClaimed;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
string memory _initContractURI
) ERC721(_name, _symbol) {
}
modifier onlyPresale() {
}
modifier onlyPublicSale() {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// presale
function addToPresaleList(address[] calldata addresses) external onlyOwner {
}
function removeFromPresaleList(address[] calldata addresses) external onlyOwner {
}
function isEligibleForPresale(address addr) external view returns (bool) {
}
function hasClaimedPresale(address addr) external view returns (bool) {
}
function togglePresaleStatus() external onlyOwner {
}
function togglePublicSaleStatus() external onlyOwner {
}
// public
function claimReserved(uint256 quantity, address addr) external onlyOwner {
}
function claimPresale() external payable onlyPresale {
}
function mint(uint256 quantity) external payable onlyPublicSale {
require(!paused, "the contract is paused");
require(tx.origin == msg.sender, "GO_AWAY_BOT");
require(totalSupply() < TOTALSALECOUNT, "SOLD_OUT");
require(quantity > 0, "QUANTITY_CANNOT_BE_ZERO");
require(quantity <= MAXMINTAMOUNT, "max mint amount per session exceeded");
require(totalSupply() + quantity <= TOTALSALECOUNT, "EXCEEDS_MAX_SUPPLY");
require(<FILL_ME>)
require(COST * quantity == msg.value, "INVALID_ETH_AMOUNT");
for(uint256 i = 0; i < quantity; i++) {
_totalClaimed[msg.sender] += 1;
_safeMint(msg.sender, totalSupply() + 1);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setContractUri(string memory _newContractURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| _totalClaimed[msg.sender]+quantity<=NFTPERADDRESSLIMIT,"EXCEEDS_MAX_ALLOWANCE" | 289,927 | _totalClaimed[msg.sender]+quantity<=NFTPERADDRESSLIMIT |
"Cannot stake less than 2 CHONK" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.2;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity 0.6.2;
interface IChonkNFT {
function mint(address to, uint256 id, uint256 amount) external;
}
contract ChonkFarm is Ownable, ReentrancyGuard {
using SafeMath for uint256;
constructor(address _chonk, address _nft) public {
}
address public ChonkAddress;
address public NFTAddress;
function setNFTAddress(address _address) public onlyOwner {
}
mapping(address => uint256) private chonkBalance;
mapping(address => uint256) public lastUpdateTime;
mapping(address => uint256) public points;
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
/*
The block.timestamp environment variable is used to determine a control flow decision.
Note that the values of variables like coinbase, gaslimit, block number and timestamp are predictable and can be manipulated by a malicious miner.
Also keep in mind that attackers know hashes of earlier blocks.
Don't use any of those environment variables as sources of randomness and be aware that use of these variables introduces a certain level of trust into miners.
https://swcregistry.io/docs/SWC-116
AUDITOR NOTE: It appers that intent of this function is to add incremental rewards over time.
Thus this vulnerability is not relly applicable to this function.
*/
function earned(address account) public view returns (uint256) {
}
/*
An external message call to an address specified by the caller is executed.
Note that the callee account might contain arbitrary code and could re-enter any function within this contract.
Reentering the contract in an intermediate state may lead to unexpected behaviour.
Make sure that no state modifications are executed after this call and/or reentrancy guards are in place.
https://swcregistry.io/docs/SWC-107
AUDITOR NOTE: Fix implmented, and vulnerable code commented out.
*/
function stake(uint256 amount) public updateReward(_msgSender()) nonReentrant {
require(<FILL_ME>)
require(amount.add(balanceOf(_msgSender())) <= 10000000000000000000, "Cannot stake more than 10 CHONK");
chonkBalance[_msgSender()] = chonkBalance[_msgSender()].add(amount);
IERC20(ChonkAddress).transferFrom(_msgSender(), address(this), amount);
emit Staked(_msgSender(), amount);
}
function withdraw(uint256 amount) public updateReward(_msgSender()) nonReentrant {
}
function exit() external {
}
mapping(uint256 => uint256) public redeemCost;
event ListCard(uint256 id, uint256 cost);
function setRedeemCost(uint256 _id, uint256 _cost) public onlyOwner {
}
function redeem(uint256 _id) public updateReward(_msgSender()) nonReentrant {
}
}
| amount.add(balanceOf(_msgSender()))>=2000000000000000000,"Cannot stake less than 2 CHONK" | 289,978 | amount.add(balanceOf(_msgSender()))>=2000000000000000000 |
"Cannot stake more than 10 CHONK" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.2;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity 0.6.2;
interface IChonkNFT {
function mint(address to, uint256 id, uint256 amount) external;
}
contract ChonkFarm is Ownable, ReentrancyGuard {
using SafeMath for uint256;
constructor(address _chonk, address _nft) public {
}
address public ChonkAddress;
address public NFTAddress;
function setNFTAddress(address _address) public onlyOwner {
}
mapping(address => uint256) private chonkBalance;
mapping(address => uint256) public lastUpdateTime;
mapping(address => uint256) public points;
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
/*
The block.timestamp environment variable is used to determine a control flow decision.
Note that the values of variables like coinbase, gaslimit, block number and timestamp are predictable and can be manipulated by a malicious miner.
Also keep in mind that attackers know hashes of earlier blocks.
Don't use any of those environment variables as sources of randomness and be aware that use of these variables introduces a certain level of trust into miners.
https://swcregistry.io/docs/SWC-116
AUDITOR NOTE: It appers that intent of this function is to add incremental rewards over time.
Thus this vulnerability is not relly applicable to this function.
*/
function earned(address account) public view returns (uint256) {
}
/*
An external message call to an address specified by the caller is executed.
Note that the callee account might contain arbitrary code and could re-enter any function within this contract.
Reentering the contract in an intermediate state may lead to unexpected behaviour.
Make sure that no state modifications are executed after this call and/or reentrancy guards are in place.
https://swcregistry.io/docs/SWC-107
AUDITOR NOTE: Fix implmented, and vulnerable code commented out.
*/
function stake(uint256 amount) public updateReward(_msgSender()) nonReentrant {
require(amount.add(balanceOf(_msgSender())) >= 2000000000000000000, "Cannot stake less than 2 CHONK");
require(<FILL_ME>)
chonkBalance[_msgSender()] = chonkBalance[_msgSender()].add(amount);
IERC20(ChonkAddress).transferFrom(_msgSender(), address(this), amount);
emit Staked(_msgSender(), amount);
}
function withdraw(uint256 amount) public updateReward(_msgSender()) nonReentrant {
}
function exit() external {
}
mapping(uint256 => uint256) public redeemCost;
event ListCard(uint256 id, uint256 cost);
function setRedeemCost(uint256 _id, uint256 _cost) public onlyOwner {
}
function redeem(uint256 _id) public updateReward(_msgSender()) nonReentrant {
}
}
| amount.add(balanceOf(_msgSender()))<=10000000000000000000,"Cannot stake more than 10 CHONK" | 289,978 | amount.add(balanceOf(_msgSender()))<=10000000000000000000 |
"Not enough points to redeem" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.2;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity 0.6.2;
interface IChonkNFT {
function mint(address to, uint256 id, uint256 amount) external;
}
contract ChonkFarm is Ownable, ReentrancyGuard {
using SafeMath for uint256;
constructor(address _chonk, address _nft) public {
}
address public ChonkAddress;
address public NFTAddress;
function setNFTAddress(address _address) public onlyOwner {
}
mapping(address => uint256) private chonkBalance;
mapping(address => uint256) public lastUpdateTime;
mapping(address => uint256) public points;
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
modifier updateReward(address account) {
}
function balanceOf(address account) public view returns (uint256) {
}
/*
The block.timestamp environment variable is used to determine a control flow decision.
Note that the values of variables like coinbase, gaslimit, block number and timestamp are predictable and can be manipulated by a malicious miner.
Also keep in mind that attackers know hashes of earlier blocks.
Don't use any of those environment variables as sources of randomness and be aware that use of these variables introduces a certain level of trust into miners.
https://swcregistry.io/docs/SWC-116
AUDITOR NOTE: It appers that intent of this function is to add incremental rewards over time.
Thus this vulnerability is not relly applicable to this function.
*/
function earned(address account) public view returns (uint256) {
}
/*
An external message call to an address specified by the caller is executed.
Note that the callee account might contain arbitrary code and could re-enter any function within this contract.
Reentering the contract in an intermediate state may lead to unexpected behaviour.
Make sure that no state modifications are executed after this call and/or reentrancy guards are in place.
https://swcregistry.io/docs/SWC-107
AUDITOR NOTE: Fix implmented, and vulnerable code commented out.
*/
function stake(uint256 amount) public updateReward(_msgSender()) nonReentrant {
}
function withdraw(uint256 amount) public updateReward(_msgSender()) nonReentrant {
}
function exit() external {
}
mapping(uint256 => uint256) public redeemCost;
event ListCard(uint256 id, uint256 cost);
function setRedeemCost(uint256 _id, uint256 _cost) public onlyOwner {
}
function redeem(uint256 _id) public updateReward(_msgSender()) nonReentrant {
uint256 price = redeemCost[_id];
require(price > 0, "Card not found");
require(<FILL_ME>)
IChonkNFT(NFTAddress).mint(_msgSender(), _id, 1);
points[_msgSender()] = points[_msgSender()].sub(price);
}
}
| points[_msgSender()]>=price,"Not enough points to redeem" | 289,978 | points[_msgSender()]>=price |
'User does not exist' | /**
* CryptoDays Profi
*
* Website: https://cryptodays.club
* Email: [email protected]
*/
pragma solidity ^0.5.11;
contract CryptoDaysProfi {
address public creator;
uint public currentUserID;
CryptoDaysProfi public oldSC = CryptoDaysProfi(0xaffF4B3acDBf54deAE7B79B8c6a49f06F9e8B0EA);
uint oldSCUserId = 1;
mapping (uint => uint) public levelPrice;
mapping (address => User) public users;
mapping (uint => address) public userAddresses;
uint MAX_LEVEL = 8;
uint REFERRALS_LIMIT = 2;
uint LEVEL_DURATION = 300 days;
struct User {
uint id;
uint referrerID;
address[] referrals;
mapping (uint => uint) levelExpiresAt;
}
event RegisterUserEvent(address indexed user, address indexed referrer, uint time, uint id, uint expires);
event BuyLevelEvent(address indexed user, uint indexed level, uint time, uint expires);
event GetLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
event LostLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
modifier userNotRegistered() {
}
modifier userRegistered() {
require(<FILL_ME>)
_;
}
modifier validReferrerID(uint _referrerID) {
}
modifier validLevel(uint _level) {
}
modifier validLevelAmount(uint _level) {
}
constructor() public {
}
function () external payable {
}
function syncWithOldSC(uint limit) public {
}
function syncClose() external {
}
function registerUser(uint _referrerID) public payable userNotRegistered() validReferrerID(_referrerID) validLevelAmount(1) {
}
function buyLevel(uint _level) public payable userRegistered() validLevel(_level) validLevelAmount(_level) {
}
function findReferrer(address _user) public view returns (address) {
}
function transferLevelPayment(uint _level, address _user) internal {
}
function getUserUpline(address _user, uint height) public view returns (address) {
}
function getUserReferrals(address _user) public view returns (address[] memory) {
}
function getUserLevelExpiresAt(address _user, uint _level) public view returns (uint) {
}
function createNewUser(uint _referrerID) private view returns (User memory) {
}
function bytesToAddress(bytes memory _addr) private pure returns (address addr) {
}
function addressToPayable(address _addr) private pure returns (address payable) {
}
}
| users[msg.sender].id!=0,'User does not exist' | 290,008 | users[msg.sender].id!=0 |
'Initialize closed' | /**
* CryptoDays Profi
*
* Website: https://cryptodays.club
* Email: [email protected]
*/
pragma solidity ^0.5.11;
contract CryptoDaysProfi {
address public creator;
uint public currentUserID;
CryptoDaysProfi public oldSC = CryptoDaysProfi(0xaffF4B3acDBf54deAE7B79B8c6a49f06F9e8B0EA);
uint oldSCUserId = 1;
mapping (uint => uint) public levelPrice;
mapping (address => User) public users;
mapping (uint => address) public userAddresses;
uint MAX_LEVEL = 8;
uint REFERRALS_LIMIT = 2;
uint LEVEL_DURATION = 300 days;
struct User {
uint id;
uint referrerID;
address[] referrals;
mapping (uint => uint) levelExpiresAt;
}
event RegisterUserEvent(address indexed user, address indexed referrer, uint time, uint id, uint expires);
event BuyLevelEvent(address indexed user, uint indexed level, uint time, uint expires);
event GetLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
event LostLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
modifier userNotRegistered() {
}
modifier userRegistered() {
}
modifier validReferrerID(uint _referrerID) {
}
modifier validLevel(uint _level) {
}
modifier validLevelAmount(uint _level) {
}
constructor() public {
}
function () external payable {
}
function syncWithOldSC(uint limit) public {
require(<FILL_ME>)
require(msg.sender == creator, 'Access denied');
for(uint i = 0; i < limit; i++) {
address user = oldSC.userAddresses(oldSCUserId);
(uint id, uint referrerID) = oldSC.users(user);
if(id > 0) {
oldSCUserId++;
address ref = oldSC.userAddresses(referrerID);
if(users[user].id == 0 && users[ref].id > 0) {
users[user].id = ++currentUserID;
users[user].referrerID = users[ref].id;
userAddresses[currentUserID] = user;
users[ref].referrals.push(user);
for(uint j = 1; j <= MAX_LEVEL; j++) {
uint t = oldSC.getUserLevelExpiresAt(user, j);
if(t > 0) users[user].levelExpiresAt[j] = t + 300 days;
}
emit RegisterUserEvent(user, ref,block.timestamp, currentUserID, users[user].levelExpiresAt[1]);
}
}
else break;
}
}
function syncClose() external {
}
function registerUser(uint _referrerID) public payable userNotRegistered() validReferrerID(_referrerID) validLevelAmount(1) {
}
function buyLevel(uint _level) public payable userRegistered() validLevel(_level) validLevelAmount(_level) {
}
function findReferrer(address _user) public view returns (address) {
}
function transferLevelPayment(uint _level, address _user) internal {
}
function getUserUpline(address _user, uint height) public view returns (address) {
}
function getUserReferrals(address _user) public view returns (address[] memory) {
}
function getUserLevelExpiresAt(address _user, uint _level) public view returns (uint) {
}
function createNewUser(uint _referrerID) private view returns (User memory) {
}
function bytesToAddress(bytes memory _addr) private pure returns (address addr) {
}
function addressToPayable(address _addr) private pure returns (address payable) {
}
}
| address(oldSC)!=address(0),'Initialize closed' | 290,008 | address(oldSC)!=address(0) |
'Buy the previous level' | /**
* CryptoDays Profi
*
* Website: https://cryptodays.club
* Email: [email protected]
*/
pragma solidity ^0.5.11;
contract CryptoDaysProfi {
address public creator;
uint public currentUserID;
CryptoDaysProfi public oldSC = CryptoDaysProfi(0xaffF4B3acDBf54deAE7B79B8c6a49f06F9e8B0EA);
uint oldSCUserId = 1;
mapping (uint => uint) public levelPrice;
mapping (address => User) public users;
mapping (uint => address) public userAddresses;
uint MAX_LEVEL = 8;
uint REFERRALS_LIMIT = 2;
uint LEVEL_DURATION = 300 days;
struct User {
uint id;
uint referrerID;
address[] referrals;
mapping (uint => uint) levelExpiresAt;
}
event RegisterUserEvent(address indexed user, address indexed referrer, uint time, uint id, uint expires);
event BuyLevelEvent(address indexed user, uint indexed level, uint time, uint expires);
event GetLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
event LostLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time);
modifier userNotRegistered() {
}
modifier userRegistered() {
}
modifier validReferrerID(uint _referrerID) {
}
modifier validLevel(uint _level) {
}
modifier validLevelAmount(uint _level) {
}
constructor() public {
}
function () external payable {
}
function syncWithOldSC(uint limit) public {
}
function syncClose() external {
}
function registerUser(uint _referrerID) public payable userNotRegistered() validReferrerID(_referrerID) validLevelAmount(1) {
}
function buyLevel(uint _level) public payable userRegistered() validLevel(_level) validLevelAmount(_level) {
for (uint l = _level - 1; l > 0; l--) {
require(<FILL_ME>)
}
if (getUserLevelExpiresAt(msg.sender, _level) < now) {
users[msg.sender].levelExpiresAt[_level] = now + LEVEL_DURATION;
} else {
users[msg.sender].levelExpiresAt[_level] += LEVEL_DURATION;
}
transferLevelPayment(_level, msg.sender);
emit BuyLevelEvent(msg.sender, _level, now, users[msg.sender].levelExpiresAt[_level]);
}
function findReferrer(address _user) public view returns (address) {
}
function transferLevelPayment(uint _level, address _user) internal {
}
function getUserUpline(address _user, uint height) public view returns (address) {
}
function getUserReferrals(address _user) public view returns (address[] memory) {
}
function getUserLevelExpiresAt(address _user, uint _level) public view returns (uint) {
}
function createNewUser(uint _referrerID) private view returns (User memory) {
}
function bytesToAddress(bytes memory _addr) private pure returns (address addr) {
}
function addressToPayable(address _addr) private pure returns (address payable) {
}
}
| getUserLevelExpiresAt(msg.sender,l)>=now,'Buy the previous level' | 290,008 | getUserLevelExpiresAt(msg.sender,l)>=now |
"Not enough tokens staked" | pragma solidity =0.6.6;
// The Staker locks up LP tokens and STBZ tokens, users need to lockup for a time specified in the claimer before redeeming cashback
// After each cashback claim, there is a timelock to remove LP set to 24 hours
// This contract is designed to consider transfer fees for when STBZ starts to charge it. It takes the fee from the user upon unstake
interface Claimer {
function getMinSTBZStake() external view returns (uint256);
function getLastClaimTime(address) external view returns (uint256);
function stakerUpdateBalance(address,uint256) external;
}
interface STBZToken {
function burnRate() external view returns (uint256);
}
contract StabinolStaker is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// variables
address public stbzAddress; // The address for the STBZ tokens
address public stolAddress; // The address for STOL
address public lpAddress; // The address for the lp
address public claimerAddress = address(0); // This can be updated by governance
uint256 public minLPStakeTime = 24 hours; // This is the minimum time the user must wait to unstake LP after a previous claim
uint256 public totalSTBZ;
uint256 public totalLP;
uint256 constant DIVISION_FACTOR = 100000;
mapping(address => UserInfo) private allUsersInfo;
// Structs
struct UserInfo {
uint256 stbzAmount; // How many stbz the user has in contract
uint256 lpAmount; // How many LP tokens the user has in contract
uint256 lastDeposit; // Time at last deposit action (either staking LP or stbz)
uint256 lastWithdraw; // Time at last withdraw action (either staking LP or stbz)
}
// Events
event StakedSTBZ(address indexed user, uint256 amount);
event StakedLP(address indexed user, uint256 amount);
event WithdrawnSTBZ(address indexed user, uint256 amount);
event WithdrawnLP(address indexed user, uint256 amount);
constructor(
address _stbz,
address _stol,
address _lp
) public {
}
// functions
function getSTOLInLP(address _user) external view returns (uint256){
}
function getLPBalance(address _user) external view returns (uint256){
}
function getSTBZBalance(address _user) external view returns (uint256){
}
function getDepositTime(address _user) external view returns (uint256){
}
function getWithdrawTime(address _user) external view returns (uint256){
}
// User can force update her/his balance if it increases, extends claim window though
function updateMyBalance() external nonReentrant
{
}
// Stake functions
function stakeSTBZ() external nonReentrant
{
uint256 gasAllocated = gasleft().mul(tx.gasprice); // Factor in the gas allocated for this transaction, it affects the eth balance
require(claimerAddress != address(0), "Claimer not set yet");
uint256 min = Claimer(claimerAddress).getMinSTBZStake(); // This will return the minimum amount of STBZ needed to stake
require(min > allUsersInfo[_msgSender()].stbzAmount, "Already staked enough STBZ in contract");
uint256 amount = min.sub(allUsersInfo[_msgSender()].stbzAmount); // This is the amount needed to top off account
allUsersInfo[_msgSender()].lastDeposit = now;
Claimer(claimerAddress).stakerUpdateBalance(_msgSender(), gasAllocated); // Update the eth balance of the user in claim contract
IERC20 _token = IERC20(stbzAddress); // Trusted token
uint256 _before = _token.balanceOf(address(this));
_token.safeTransferFrom(_msgSender(), address(this), amount); // Transfer token to this address
amount = _token.balanceOf(address(this)).sub(_before); // Some tokens lose amount (transfer fee) upon transfer can happen
totalSTBZ = totalSTBZ.add(amount);
allUsersInfo[_msgSender()].stbzAmount = allUsersInfo[_msgSender()].stbzAmount.add(amount);
require(<FILL_ME>)
emit StakedSTBZ(_msgSender(), amount);
}
function stakeSTOLLP(uint256 amount) external nonReentrant
{
}
// Unstake functions
// This will unstake the entire STBZ amount staked, user can unstake STBZ at any time
// It takes into account the STBZ burn fee that is taken from the sender by implementing a withdraw fee
function unstakeSTBZ() external nonReentrant
{
}
// User can unstake only after timelock time
function unstakeLP(uint256 amount) external nonReentrant
{
}
// Governance only functions
// Timelock variables
// Timelock doesn't activate until claimer address set
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256 private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the claimer contract
// --------------------
function startClaimerChange(address _address) external onlyGovernance {
}
function finishClaimerChange() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the LP lockup time since last claim time
// --------------------
function startChangeLPTimeLock(uint256 _time) external onlyGovernance {
}
function finishChangeLPTimeLock() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
}
| allUsersInfo[_msgSender()].stbzAmount>=min,"Not enough tokens staked" | 290,044 | allUsersInfo[_msgSender()].stbzAmount>=min |
"There is no STBZ balance for this user" | pragma solidity =0.6.6;
// The Staker locks up LP tokens and STBZ tokens, users need to lockup for a time specified in the claimer before redeeming cashback
// After each cashback claim, there is a timelock to remove LP set to 24 hours
// This contract is designed to consider transfer fees for when STBZ starts to charge it. It takes the fee from the user upon unstake
interface Claimer {
function getMinSTBZStake() external view returns (uint256);
function getLastClaimTime(address) external view returns (uint256);
function stakerUpdateBalance(address,uint256) external;
}
interface STBZToken {
function burnRate() external view returns (uint256);
}
contract StabinolStaker is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// variables
address public stbzAddress; // The address for the STBZ tokens
address public stolAddress; // The address for STOL
address public lpAddress; // The address for the lp
address public claimerAddress = address(0); // This can be updated by governance
uint256 public minLPStakeTime = 24 hours; // This is the minimum time the user must wait to unstake LP after a previous claim
uint256 public totalSTBZ;
uint256 public totalLP;
uint256 constant DIVISION_FACTOR = 100000;
mapping(address => UserInfo) private allUsersInfo;
// Structs
struct UserInfo {
uint256 stbzAmount; // How many stbz the user has in contract
uint256 lpAmount; // How many LP tokens the user has in contract
uint256 lastDeposit; // Time at last deposit action (either staking LP or stbz)
uint256 lastWithdraw; // Time at last withdraw action (either staking LP or stbz)
}
// Events
event StakedSTBZ(address indexed user, uint256 amount);
event StakedLP(address indexed user, uint256 amount);
event WithdrawnSTBZ(address indexed user, uint256 amount);
event WithdrawnLP(address indexed user, uint256 amount);
constructor(
address _stbz,
address _stol,
address _lp
) public {
}
// functions
function getSTOLInLP(address _user) external view returns (uint256){
}
function getLPBalance(address _user) external view returns (uint256){
}
function getSTBZBalance(address _user) external view returns (uint256){
}
function getDepositTime(address _user) external view returns (uint256){
}
function getWithdrawTime(address _user) external view returns (uint256){
}
// User can force update her/his balance if it increases, extends claim window though
function updateMyBalance() external nonReentrant
{
}
// Stake functions
function stakeSTBZ() external nonReentrant
{
}
function stakeSTOLLP(uint256 amount) external nonReentrant
{
}
// Unstake functions
// This will unstake the entire STBZ amount staked, user can unstake STBZ at any time
// It takes into account the STBZ burn fee that is taken from the sender by implementing a withdraw fee
function unstakeSTBZ() external nonReentrant
{
require(<FILL_ME>)
uint256 feeRate = STBZToken(stbzAddress).burnRate();
if(feeRate > 0){
feeRate = (feeRate * DIVISION_FACTOR) / (DIVISION_FACTOR + feeRate); // Unique formula to calcuate fee upon sending
}
uint256 feeAmount = allUsersInfo[_msgSender()].stbzAmount.mul(feeRate).div(DIVISION_FACTOR);
uint256 sendAmount = allUsersInfo[_msgSender()].stbzAmount.sub(feeAmount);
totalSTBZ = totalSTBZ.sub(allUsersInfo[_msgSender()].stbzAmount);
allUsersInfo[_msgSender()].stbzAmount = 0;
allUsersInfo[_msgSender()].lastWithdraw = now;
IERC20(stbzAddress).safeTransfer(_msgSender(), sendAmount);
emit WithdrawnSTBZ(_msgSender(), sendAmount.add(feeAmount));
}
// User can unstake only after timelock time
function unstakeLP(uint256 amount) external nonReentrant
{
}
// Governance only functions
// Timelock variables
// Timelock doesn't activate until claimer address set
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256 private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the claimer contract
// --------------------
function startClaimerChange(address _address) external onlyGovernance {
}
function finishClaimerChange() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the LP lockup time since last claim time
// --------------------
function startChangeLPTimeLock(uint256 _time) external onlyGovernance {
}
function finishChangeLPTimeLock() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
}
| allUsersInfo[_msgSender()].stbzAmount>0,"There is no STBZ balance for this user" | 290,044 | allUsersInfo[_msgSender()].stbzAmount>0 |
"There is no LP balance for this user" | pragma solidity =0.6.6;
// The Staker locks up LP tokens and STBZ tokens, users need to lockup for a time specified in the claimer before redeeming cashback
// After each cashback claim, there is a timelock to remove LP set to 24 hours
// This contract is designed to consider transfer fees for when STBZ starts to charge it. It takes the fee from the user upon unstake
interface Claimer {
function getMinSTBZStake() external view returns (uint256);
function getLastClaimTime(address) external view returns (uint256);
function stakerUpdateBalance(address,uint256) external;
}
interface STBZToken {
function burnRate() external view returns (uint256);
}
contract StabinolStaker is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// variables
address public stbzAddress; // The address for the STBZ tokens
address public stolAddress; // The address for STOL
address public lpAddress; // The address for the lp
address public claimerAddress = address(0); // This can be updated by governance
uint256 public minLPStakeTime = 24 hours; // This is the minimum time the user must wait to unstake LP after a previous claim
uint256 public totalSTBZ;
uint256 public totalLP;
uint256 constant DIVISION_FACTOR = 100000;
mapping(address => UserInfo) private allUsersInfo;
// Structs
struct UserInfo {
uint256 stbzAmount; // How many stbz the user has in contract
uint256 lpAmount; // How many LP tokens the user has in contract
uint256 lastDeposit; // Time at last deposit action (either staking LP or stbz)
uint256 lastWithdraw; // Time at last withdraw action (either staking LP or stbz)
}
// Events
event StakedSTBZ(address indexed user, uint256 amount);
event StakedLP(address indexed user, uint256 amount);
event WithdrawnSTBZ(address indexed user, uint256 amount);
event WithdrawnLP(address indexed user, uint256 amount);
constructor(
address _stbz,
address _stol,
address _lp
) public {
}
// functions
function getSTOLInLP(address _user) external view returns (uint256){
}
function getLPBalance(address _user) external view returns (uint256){
}
function getSTBZBalance(address _user) external view returns (uint256){
}
function getDepositTime(address _user) external view returns (uint256){
}
function getWithdrawTime(address _user) external view returns (uint256){
}
// User can force update her/his balance if it increases, extends claim window though
function updateMyBalance() external nonReentrant
{
}
// Stake functions
function stakeSTBZ() external nonReentrant
{
}
function stakeSTOLLP(uint256 amount) external nonReentrant
{
}
// Unstake functions
// This will unstake the entire STBZ amount staked, user can unstake STBZ at any time
// It takes into account the STBZ burn fee that is taken from the sender by implementing a withdraw fee
function unstakeSTBZ() external nonReentrant
{
}
// User can unstake only after timelock time
function unstakeLP(uint256 amount) external nonReentrant
{
require(<FILL_ME>)
require(claimerAddress != address(0), "Claimer not set yet");
uint256 lastClaim = Claimer(claimerAddress).getLastClaimTime(_msgSender());
require(now >= lastClaim + minLPStakeTime, "Last claim too recent to unstake LP");
totalLP = totalLP.sub(amount);
allUsersInfo[_msgSender()].lpAmount = allUsersInfo[_msgSender()].lpAmount.sub(amount);
allUsersInfo[_msgSender()].lastWithdraw = now;
IERC20(lpAddress).safeTransfer(_msgSender(), amount);
emit WithdrawnLP(_msgSender(), amount);
}
// Governance only functions
// Timelock variables
// Timelock doesn't activate until claimer address set
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256 private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the claimer contract
// --------------------
function startClaimerChange(address _address) external onlyGovernance {
}
function finishClaimerChange() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the LP lockup time since last claim time
// --------------------
function startChangeLPTimeLock(uint256 _time) external onlyGovernance {
}
function finishChangeLPTimeLock() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
}
| allUsersInfo[_msgSender()].lpAmount>0,"There is no LP balance for this user" | 290,044 | allUsersInfo[_msgSender()].lpAmount>0 |
"Max supply exceeded!" | // SPDX-License-Identifier: MIT
/*
___ __ __ ___ ___ ___ ___ ___
/ \ \ \ / / | __| | _ \ / \ / __| | __|
| - | \ V / | _| | / | - | | (_ | | _|
|_|_| _\_/_ |___| |_|_\ |_|_| \___| |___|
_|"""""|_| """"|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
*/
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract AverageCreatures is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public reserved;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address t1 = 0xeB86Ce06100B3aa38F4ee677be9f8dBeA122b5EC;
address t2 = 0xcafcF97cc06C3646359C880285c8F5C42aB07e77;
address t3 = 0x7576bA2d85fB8188B412A59F2F2317408f28317D;
address t4 = 0xC6642dc3Bc7f693561AdB38A3f841ED8B7B88565;
address t5 = 0xAFe515D7E7f7a95b9F8D4c8e745983F934FfAE2e;
address t6 = 0x2BC549c48c0bFb942E994EfB91b6232DB46157db;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _reserved,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(<FILL_ME>)
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
modifier giveawayCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public giveawayCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setReserved(uint256 _reserved) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| supply.current()+_mintAmount<=maxSupply-reserved,"Max supply exceeded!" | 290,128 | supply.current()+_mintAmount<=maxSupply-reserved |
null | // SPDX-License-Identifier: MIT
/*
___ __ __ ___ ___ ___ ___ ___
/ \ \ \ / / | __| | _ \ / \ / __| | __|
| - | \ V / | _| | / | - | | (_ | | _|
|_|_| _\_/_ |___| |_|_\ |_|_| \___| |___|
_|"""""|_| """"|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
*/
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract AverageCreatures is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public reserved;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address t1 = 0xeB86Ce06100B3aa38F4ee677be9f8dBeA122b5EC;
address t2 = 0xcafcF97cc06C3646359C880285c8F5C42aB07e77;
address t3 = 0x7576bA2d85fB8188B412A59F2F2317408f28317D;
address t4 = 0xC6642dc3Bc7f693561AdB38A3f841ED8B7B88565;
address t5 = 0xAFe515D7E7f7a95b9F8D4c8e745983F934FfAE2e;
address t6 = 0x2BC549c48c0bFb942E994EfB91b6232DB46157db;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _reserved,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
modifier giveawayCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public giveawayCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setReserved(uint256 _reserved) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
uint256 _each = address(this).balance / 100 ;
require(<FILL_ME>)
require(payable(t2).send(_each * 20));
require(payable(t3).send(_each * 20));
require(payable(t4).send(_each * 5));
require(payable(t5).send(_each * 5));
require(payable(t6).send(_each * 10));
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| payable(t1).send(_each*40) | 290,128 | payable(t1).send(_each*40) |
null | // SPDX-License-Identifier: MIT
/*
___ __ __ ___ ___ ___ ___ ___
/ \ \ \ / / | __| | _ \ / \ / __| | __|
| - | \ V / | _| | / | - | | (_ | | _|
|_|_| _\_/_ |___| |_|_\ |_|_| \___| |___|
_|"""""|_| """"|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
*/
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract AverageCreatures is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public reserved;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address t1 = 0xeB86Ce06100B3aa38F4ee677be9f8dBeA122b5EC;
address t2 = 0xcafcF97cc06C3646359C880285c8F5C42aB07e77;
address t3 = 0x7576bA2d85fB8188B412A59F2F2317408f28317D;
address t4 = 0xC6642dc3Bc7f693561AdB38A3f841ED8B7B88565;
address t5 = 0xAFe515D7E7f7a95b9F8D4c8e745983F934FfAE2e;
address t6 = 0x2BC549c48c0bFb942E994EfB91b6232DB46157db;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _reserved,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
modifier giveawayCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public giveawayCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setReserved(uint256 _reserved) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
uint256 _each = address(this).balance / 100 ;
require(payable(t1).send(_each * 40));
require(<FILL_ME>)
require(payable(t3).send(_each * 20));
require(payable(t4).send(_each * 5));
require(payable(t5).send(_each * 5));
require(payable(t6).send(_each * 10));
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| payable(t2).send(_each*20) | 290,128 | payable(t2).send(_each*20) |
null | // SPDX-License-Identifier: MIT
/*
___ __ __ ___ ___ ___ ___ ___
/ \ \ \ / / | __| | _ \ / \ / __| | __|
| - | \ V / | _| | / | - | | (_ | | _|
|_|_| _\_/_ |___| |_|_\ |_|_| \___| |___|
_|"""""|_| """"|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
*/
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract AverageCreatures is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public reserved;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address t1 = 0xeB86Ce06100B3aa38F4ee677be9f8dBeA122b5EC;
address t2 = 0xcafcF97cc06C3646359C880285c8F5C42aB07e77;
address t3 = 0x7576bA2d85fB8188B412A59F2F2317408f28317D;
address t4 = 0xC6642dc3Bc7f693561AdB38A3f841ED8B7B88565;
address t5 = 0xAFe515D7E7f7a95b9F8D4c8e745983F934FfAE2e;
address t6 = 0x2BC549c48c0bFb942E994EfB91b6232DB46157db;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _reserved,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
modifier giveawayCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public giveawayCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setReserved(uint256 _reserved) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
uint256 _each = address(this).balance / 100 ;
require(payable(t1).send(_each * 40));
require(payable(t2).send(_each * 20));
require(<FILL_ME>)
require(payable(t4).send(_each * 5));
require(payable(t5).send(_each * 5));
require(payable(t6).send(_each * 10));
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| payable(t3).send(_each*20) | 290,128 | payable(t3).send(_each*20) |
null | // SPDX-License-Identifier: MIT
/*
___ __ __ ___ ___ ___ ___ ___
/ \ \ \ / / | __| | _ \ / \ / __| | __|
| - | \ V / | _| | / | - | | (_ | | _|
|_|_| _\_/_ |___| |_|_\ |_|_| \___| |___|
_|"""""|_| """"|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
*/
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract AverageCreatures is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public reserved;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address t1 = 0xeB86Ce06100B3aa38F4ee677be9f8dBeA122b5EC;
address t2 = 0xcafcF97cc06C3646359C880285c8F5C42aB07e77;
address t3 = 0x7576bA2d85fB8188B412A59F2F2317408f28317D;
address t4 = 0xC6642dc3Bc7f693561AdB38A3f841ED8B7B88565;
address t5 = 0xAFe515D7E7f7a95b9F8D4c8e745983F934FfAE2e;
address t6 = 0x2BC549c48c0bFb942E994EfB91b6232DB46157db;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _reserved,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
modifier giveawayCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public giveawayCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setReserved(uint256 _reserved) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
uint256 _each = address(this).balance / 100 ;
require(payable(t1).send(_each * 40));
require(payable(t2).send(_each * 20));
require(payable(t3).send(_each * 20));
require(<FILL_ME>)
require(payable(t5).send(_each * 5));
require(payable(t6).send(_each * 10));
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| payable(t4).send(_each*5) | 290,128 | payable(t4).send(_each*5) |
null | // SPDX-License-Identifier: MIT
/*
___ __ __ ___ ___ ___ ___ ___
/ \ \ \ / / | __| | _ \ / \ / __| | __|
| - | \ V / | _| | / | - | | (_ | | _|
|_|_| _\_/_ |___| |_|_\ |_|_| \___| |___|
_|"""""|_| """"|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
*/
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract AverageCreatures is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public reserved;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address t1 = 0xeB86Ce06100B3aa38F4ee677be9f8dBeA122b5EC;
address t2 = 0xcafcF97cc06C3646359C880285c8F5C42aB07e77;
address t3 = 0x7576bA2d85fB8188B412A59F2F2317408f28317D;
address t4 = 0xC6642dc3Bc7f693561AdB38A3f841ED8B7B88565;
address t5 = 0xAFe515D7E7f7a95b9F8D4c8e745983F934FfAE2e;
address t6 = 0x2BC549c48c0bFb942E994EfB91b6232DB46157db;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _reserved,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
modifier giveawayCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public giveawayCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setReserved(uint256 _reserved) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
uint256 _each = address(this).balance / 100 ;
require(payable(t1).send(_each * 40));
require(payable(t2).send(_each * 20));
require(payable(t3).send(_each * 20));
require(payable(t4).send(_each * 5));
require(<FILL_ME>)
require(payable(t6).send(_each * 10));
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| payable(t5).send(_each*5) | 290,128 | payable(t5).send(_each*5) |
null | // SPDX-License-Identifier: MIT
/*
___ __ __ ___ ___ ___ ___ ___
/ \ \ \ / / | __| | _ \ / \ / __| | __|
| - | \ V / | _| | / | - | | (_ | | _|
|_|_| _\_/_ |___| |_|_\ |_|_| \___| |___|
_|"""""|_| """"|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
*/
pragma solidity >=0.8.9 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract AverageCreatures is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public reserved;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
address t1 = 0xeB86Ce06100B3aa38F4ee677be9f8dBeA122b5EC;
address t2 = 0xcafcF97cc06C3646359C880285c8F5C42aB07e77;
address t3 = 0x7576bA2d85fB8188B412A59F2F2317408f28317D;
address t4 = 0xC6642dc3Bc7f693561AdB38A3f841ED8B7B88565;
address t5 = 0xAFe515D7E7f7a95b9F8D4c8e745983F934FfAE2e;
address t6 = 0x2BC549c48c0bFb942E994EfB91b6232DB46157db;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _reserved,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
modifier giveawayCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public giveawayCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setReserved(uint256 _reserved) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
uint256 _each = address(this).balance / 100 ;
require(payable(t1).send(_each * 40));
require(payable(t2).send(_each * 20));
require(payable(t3).send(_each * 20));
require(payable(t4).send(_each * 5));
require(payable(t5).send(_each * 5));
require(<FILL_ME>)
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| payable(t6).send(_each*10) | 290,128 | payable(t6).send(_each*10) |
"EXCEED_TEAM_MAX" | pragma solidity ^0.8.4;
contract Kaizen is Ownable, ERC721A {
string private _tokenBaseURI = "https://api.kaizen-nft.com/api/token/";
uint256 public KAI_MAX_CLAIM = 2000;
uint256 public KAI_MAX_TEAM = 222;
uint256 public claimTokensMinted;
uint256 public teamTokensMinted;
bool public publicLive;
bool public privateLive;
address private PRIVATE_SIGNER = 0x9cf3870d4FCeE7B7B740A5d2782cb266eabD23aC;
string private constant SIG_WORD = "KAIZEN_PRIVATE";
mapping(address => uint256) public PRIVATE_MINT_LIST;
using Strings for uint256;
using ECDSA for bytes32;
constructor() ERC721A("Kaizen", "KAI") {}
modifier callerIsUser() {
}
function matchAddresSigner(bytes memory signature, uint256 allowedQuantity) private view returns (bool) {
}
function gift(address[] calldata receivers) external onlyOwner {
require(<FILL_ME>)
teamTokensMinted = teamTokensMinted + receivers.length;
for (uint256 i = 0; i < receivers.length; i++) {
_safeMint(receivers[i], 1);
}
}
function founderMint(uint256 tokenQuantity) external onlyOwner {
}
function mint() external callerIsUser {
}
function privateMint(bytes memory signature, uint256 tokenQuantity, uint256 allowedQuantity) external callerIsUser {
}
function togglePublicMintStatus() external onlyOwner {
}
function togglePrivateStatus() external onlyOwner {
}
function setTeamReserve(uint256 newCount) external onlyOwner {
}
function setClaim(uint256 newCount) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| teamTokensMinted+receivers.length<=KAI_MAX_TEAM,"EXCEED_TEAM_MAX" | 290,132 | teamTokensMinted+receivers.length<=KAI_MAX_TEAM |
"EXCEED_TEAM_MAX" | pragma solidity ^0.8.4;
contract Kaizen is Ownable, ERC721A {
string private _tokenBaseURI = "https://api.kaizen-nft.com/api/token/";
uint256 public KAI_MAX_CLAIM = 2000;
uint256 public KAI_MAX_TEAM = 222;
uint256 public claimTokensMinted;
uint256 public teamTokensMinted;
bool public publicLive;
bool public privateLive;
address private PRIVATE_SIGNER = 0x9cf3870d4FCeE7B7B740A5d2782cb266eabD23aC;
string private constant SIG_WORD = "KAIZEN_PRIVATE";
mapping(address => uint256) public PRIVATE_MINT_LIST;
using Strings for uint256;
using ECDSA for bytes32;
constructor() ERC721A("Kaizen", "KAI") {}
modifier callerIsUser() {
}
function matchAddresSigner(bytes memory signature, uint256 allowedQuantity) private view returns (bool) {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function founderMint(uint256 tokenQuantity) external onlyOwner {
require(<FILL_ME>)
teamTokensMinted = teamTokensMinted + tokenQuantity;
_safeMint(msg.sender, tokenQuantity);
}
function mint() external callerIsUser {
}
function privateMint(bytes memory signature, uint256 tokenQuantity, uint256 allowedQuantity) external callerIsUser {
}
function togglePublicMintStatus() external onlyOwner {
}
function togglePrivateStatus() external onlyOwner {
}
function setTeamReserve(uint256 newCount) external onlyOwner {
}
function setClaim(uint256 newCount) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| teamTokensMinted+tokenQuantity<=KAI_MAX_TEAM,"EXCEED_TEAM_MAX" | 290,132 | teamTokensMinted+tokenQuantity<=KAI_MAX_TEAM |
"EXCEED_MAX" | pragma solidity ^0.8.4;
contract Kaizen is Ownable, ERC721A {
string private _tokenBaseURI = "https://api.kaizen-nft.com/api/token/";
uint256 public KAI_MAX_CLAIM = 2000;
uint256 public KAI_MAX_TEAM = 222;
uint256 public claimTokensMinted;
uint256 public teamTokensMinted;
bool public publicLive;
bool public privateLive;
address private PRIVATE_SIGNER = 0x9cf3870d4FCeE7B7B740A5d2782cb266eabD23aC;
string private constant SIG_WORD = "KAIZEN_PRIVATE";
mapping(address => uint256) public PRIVATE_MINT_LIST;
using Strings for uint256;
using ECDSA for bytes32;
constructor() ERC721A("Kaizen", "KAI") {}
modifier callerIsUser() {
}
function matchAddresSigner(bytes memory signature, uint256 allowedQuantity) private view returns (bool) {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function founderMint(uint256 tokenQuantity) external onlyOwner {
}
function mint() external callerIsUser {
require(publicLive, "MINT_CLOSED");
require(<FILL_ME>)
claimTokensMinted++;
_safeMint(msg.sender, 1);
}
function privateMint(bytes memory signature, uint256 tokenQuantity, uint256 allowedQuantity) external callerIsUser {
}
function togglePublicMintStatus() external onlyOwner {
}
function togglePrivateStatus() external onlyOwner {
}
function setTeamReserve(uint256 newCount) external onlyOwner {
}
function setClaim(uint256 newCount) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| claimTokensMinted+1<=KAI_MAX_CLAIM,"EXCEED_MAX" | 290,132 | claimTokensMinted+1<=KAI_MAX_CLAIM |
"DIRECT_MINT_DISALLOWED" | pragma solidity ^0.8.4;
contract Kaizen is Ownable, ERC721A {
string private _tokenBaseURI = "https://api.kaizen-nft.com/api/token/";
uint256 public KAI_MAX_CLAIM = 2000;
uint256 public KAI_MAX_TEAM = 222;
uint256 public claimTokensMinted;
uint256 public teamTokensMinted;
bool public publicLive;
bool public privateLive;
address private PRIVATE_SIGNER = 0x9cf3870d4FCeE7B7B740A5d2782cb266eabD23aC;
string private constant SIG_WORD = "KAIZEN_PRIVATE";
mapping(address => uint256) public PRIVATE_MINT_LIST;
using Strings for uint256;
using ECDSA for bytes32;
constructor() ERC721A("Kaizen", "KAI") {}
modifier callerIsUser() {
}
function matchAddresSigner(bytes memory signature, uint256 allowedQuantity) private view returns (bool) {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function founderMint(uint256 tokenQuantity) external onlyOwner {
}
function mint() external callerIsUser {
}
function privateMint(bytes memory signature, uint256 tokenQuantity, uint256 allowedQuantity) external callerIsUser {
require(privateLive, "MINT_CLOSED");
require(<FILL_ME>)
require(PRIVATE_MINT_LIST[msg.sender] + tokenQuantity <= allowedQuantity, "EXCEED_ALLOWED");
require(claimTokensMinted + tokenQuantity <= KAI_MAX_CLAIM, "EXCEED_MAX");
PRIVATE_MINT_LIST[msg.sender] = PRIVATE_MINT_LIST[msg.sender] + tokenQuantity;
claimTokensMinted = claimTokensMinted + tokenQuantity;
_safeMint(msg.sender, tokenQuantity);
}
function togglePublicMintStatus() external onlyOwner {
}
function togglePrivateStatus() external onlyOwner {
}
function setTeamReserve(uint256 newCount) external onlyOwner {
}
function setClaim(uint256 newCount) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| matchAddresSigner(signature,allowedQuantity),"DIRECT_MINT_DISALLOWED" | 290,132 | matchAddresSigner(signature,allowedQuantity) |
"EXCEED_ALLOWED" | pragma solidity ^0.8.4;
contract Kaizen is Ownable, ERC721A {
string private _tokenBaseURI = "https://api.kaizen-nft.com/api/token/";
uint256 public KAI_MAX_CLAIM = 2000;
uint256 public KAI_MAX_TEAM = 222;
uint256 public claimTokensMinted;
uint256 public teamTokensMinted;
bool public publicLive;
bool public privateLive;
address private PRIVATE_SIGNER = 0x9cf3870d4FCeE7B7B740A5d2782cb266eabD23aC;
string private constant SIG_WORD = "KAIZEN_PRIVATE";
mapping(address => uint256) public PRIVATE_MINT_LIST;
using Strings for uint256;
using ECDSA for bytes32;
constructor() ERC721A("Kaizen", "KAI") {}
modifier callerIsUser() {
}
function matchAddresSigner(bytes memory signature, uint256 allowedQuantity) private view returns (bool) {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function founderMint(uint256 tokenQuantity) external onlyOwner {
}
function mint() external callerIsUser {
}
function privateMint(bytes memory signature, uint256 tokenQuantity, uint256 allowedQuantity) external callerIsUser {
require(privateLive, "MINT_CLOSED");
require(matchAddresSigner(signature, allowedQuantity), "DIRECT_MINT_DISALLOWED");
require(<FILL_ME>)
require(claimTokensMinted + tokenQuantity <= KAI_MAX_CLAIM, "EXCEED_MAX");
PRIVATE_MINT_LIST[msg.sender] = PRIVATE_MINT_LIST[msg.sender] + tokenQuantity;
claimTokensMinted = claimTokensMinted + tokenQuantity;
_safeMint(msg.sender, tokenQuantity);
}
function togglePublicMintStatus() external onlyOwner {
}
function togglePrivateStatus() external onlyOwner {
}
function setTeamReserve(uint256 newCount) external onlyOwner {
}
function setClaim(uint256 newCount) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| PRIVATE_MINT_LIST[msg.sender]+tokenQuantity<=allowedQuantity,"EXCEED_ALLOWED" | 290,132 | PRIVATE_MINT_LIST[msg.sender]+tokenQuantity<=allowedQuantity |
"EXCEED_MAX" | pragma solidity ^0.8.4;
contract Kaizen is Ownable, ERC721A {
string private _tokenBaseURI = "https://api.kaizen-nft.com/api/token/";
uint256 public KAI_MAX_CLAIM = 2000;
uint256 public KAI_MAX_TEAM = 222;
uint256 public claimTokensMinted;
uint256 public teamTokensMinted;
bool public publicLive;
bool public privateLive;
address private PRIVATE_SIGNER = 0x9cf3870d4FCeE7B7B740A5d2782cb266eabD23aC;
string private constant SIG_WORD = "KAIZEN_PRIVATE";
mapping(address => uint256) public PRIVATE_MINT_LIST;
using Strings for uint256;
using ECDSA for bytes32;
constructor() ERC721A("Kaizen", "KAI") {}
modifier callerIsUser() {
}
function matchAddresSigner(bytes memory signature, uint256 allowedQuantity) private view returns (bool) {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function founderMint(uint256 tokenQuantity) external onlyOwner {
}
function mint() external callerIsUser {
}
function privateMint(bytes memory signature, uint256 tokenQuantity, uint256 allowedQuantity) external callerIsUser {
require(privateLive, "MINT_CLOSED");
require(matchAddresSigner(signature, allowedQuantity), "DIRECT_MINT_DISALLOWED");
require(PRIVATE_MINT_LIST[msg.sender] + tokenQuantity <= allowedQuantity, "EXCEED_ALLOWED");
require(<FILL_ME>)
PRIVATE_MINT_LIST[msg.sender] = PRIVATE_MINT_LIST[msg.sender] + tokenQuantity;
claimTokensMinted = claimTokensMinted + tokenQuantity;
_safeMint(msg.sender, tokenQuantity);
}
function togglePublicMintStatus() external onlyOwner {
}
function togglePrivateStatus() external onlyOwner {
}
function setTeamReserve(uint256 newCount) external onlyOwner {
}
function setClaim(uint256 newCount) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| claimTokensMinted+tokenQuantity<=KAI_MAX_CLAIM,"EXCEED_MAX" | 290,132 | claimTokensMinted+tokenQuantity<=KAI_MAX_CLAIM |
null | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.0;
import "./OpenzeppelinERC721.sol";
contract Mikan is ERC721URIStorage {
string Messagefrom___CreatorName___ = "_______This message is written in BlockChain_______";
mapping(uint256 => string) ipfsURIMap;
mapping(uint256 => string) arweaveURIMap;
mapping(uint256 => string) onchainDataMap;
mapping(uint256 => string) additional1URIMap;
mapping(uint256 => string) additional2URIMap;
enum selectedStorageByOwner { IPFS , ARWEAVE , ADD1 , ADD2 }
mapping(uint256 => selectedStorageByOwner) selectedStorageByOwnerMap;
address staff1 = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
address staff2 = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
mapping(uint256 => string) onchainImageMap;
address public creator;
uint256 public number = 1;
event Mint();
event SetTokenURI( uint256 , string );
function mint() public {
}
function setTokenURI( uint256 _num , string memory _uri ) public{
}
function selectStorage(uint256 _id , selectedStorageByOwner _selected ) public {
require(<FILL_ME>)
selectedStorageByOwnerMap[_id] = _selected;
//emit SetTokenURI( _id , tokenURI(_id) );
}
function setIPFSURIMap(uint256 _id , string memory _ipfsURI ) public {
}
function setArweaveURIMap(uint256 _id , string memory _ArweaveURI ) public {
}
function setAdditional1URIMap(uint256 _id , string memory _add1) public {
}
//owner can set setAdditional2URIMap function
function setAdditional2URIMap(uint256 _id , string memory _add2) public {
}
function getIPFSURIMap(uint256 _id ) public view returns(string memory){
}
function getArweaveURIMap(uint256 _id ) public view returns(string memory){
}
function tokenSvgDataOf(uint256 _id ) public view returns(string memory){
}
function getOnchainImage(uint256 _id) public view returns(string memory){
}
function getAdditional1URIMap(uint256 _id ) public view returns(string memory){
}
function getAdditional2URIMap(uint256 _id ) public view returns(string memory){
}
function tokenURI(uint256 _id) override(ERC721URIStorage) public view returns (string memory) {
}
constructor() ERC721("Mikan" , "Mikan" ) {
}
}
| _msgSender()==ownerOf(_id) | 290,209 | _msgSender()==ownerOf(_id) |
null | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.0;
import "./OpenzeppelinERC721.sol";
contract Mikan is ERC721URIStorage {
string Messagefrom___CreatorName___ = "_______This message is written in BlockChain_______";
mapping(uint256 => string) ipfsURIMap;
mapping(uint256 => string) arweaveURIMap;
mapping(uint256 => string) onchainDataMap;
mapping(uint256 => string) additional1URIMap;
mapping(uint256 => string) additional2URIMap;
enum selectedStorageByOwner { IPFS , ARWEAVE , ADD1 , ADD2 }
mapping(uint256 => selectedStorageByOwner) selectedStorageByOwnerMap;
address staff1 = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
address staff2 = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
mapping(uint256 => string) onchainImageMap;
address public creator;
uint256 public number = 1;
event Mint();
event SetTokenURI( uint256 , string );
function mint() public {
}
function setTokenURI( uint256 _num , string memory _uri ) public{
}
function selectStorage(uint256 _id , selectedStorageByOwner _selected ) public {
}
function setIPFSURIMap(uint256 _id , string memory _ipfsURI ) public {
require(<FILL_ME>)
ipfsURIMap[_id] = _ipfsURI;
_setTokenURI( _id , _ipfsURI );
//emit SetTokenURI( _id , _ipfsURI );
}
function setArweaveURIMap(uint256 _id , string memory _ArweaveURI ) public {
}
function setAdditional1URIMap(uint256 _id , string memory _add1) public {
}
//owner can set setAdditional2URIMap function
function setAdditional2URIMap(uint256 _id , string memory _add2) public {
}
function getIPFSURIMap(uint256 _id ) public view returns(string memory){
}
function getArweaveURIMap(uint256 _id ) public view returns(string memory){
}
function tokenSvgDataOf(uint256 _id ) public view returns(string memory){
}
function getOnchainImage(uint256 _id) public view returns(string memory){
}
function getAdditional1URIMap(uint256 _id ) public view returns(string memory){
}
function getAdditional2URIMap(uint256 _id ) public view returns(string memory){
}
function tokenURI(uint256 _id) override(ERC721URIStorage) public view returns (string memory) {
}
constructor() ERC721("Mikan" , "Mikan" ) {
}
}
| _msgSender()==creator||_msgSender()==staff1||_msgSender()==staff2 | 290,209 | _msgSender()==creator||_msgSender()==staff1||_msgSender()==staff2 |
null | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.0;
import "./OpenzeppelinERC721.sol";
contract Mikan is ERC721URIStorage {
string Messagefrom___CreatorName___ = "_______This message is written in BlockChain_______";
mapping(uint256 => string) ipfsURIMap;
mapping(uint256 => string) arweaveURIMap;
mapping(uint256 => string) onchainDataMap;
mapping(uint256 => string) additional1URIMap;
mapping(uint256 => string) additional2URIMap;
enum selectedStorageByOwner { IPFS , ARWEAVE , ADD1 , ADD2 }
mapping(uint256 => selectedStorageByOwner) selectedStorageByOwnerMap;
address staff1 = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
address staff2 = 0xE35B827177398D8d2FBA304d9cF53bc8fC1573B7;
mapping(uint256 => string) onchainImageMap;
address public creator;
uint256 public number = 1;
event Mint();
event SetTokenURI( uint256 , string );
function mint() public {
}
function setTokenURI( uint256 _num , string memory _uri ) public{
}
function selectStorage(uint256 _id , selectedStorageByOwner _selected ) public {
}
function setIPFSURIMap(uint256 _id , string memory _ipfsURI ) public {
}
function setArweaveURIMap(uint256 _id , string memory _ArweaveURI ) public {
}
function setAdditional1URIMap(uint256 _id , string memory _add1) public {
}
//owner can set setAdditional2URIMap function
function setAdditional2URIMap(uint256 _id , string memory _add2) public {
require(<FILL_ME>)
additional2URIMap[_id] = _add2;
}
function getIPFSURIMap(uint256 _id ) public view returns(string memory){
}
function getArweaveURIMap(uint256 _id ) public view returns(string memory){
}
function tokenSvgDataOf(uint256 _id ) public view returns(string memory){
}
function getOnchainImage(uint256 _id) public view returns(string memory){
}
function getAdditional1URIMap(uint256 _id ) public view returns(string memory){
}
function getAdditional2URIMap(uint256 _id ) public view returns(string memory){
}
function tokenURI(uint256 _id) override(ERC721URIStorage) public view returns (string memory) {
}
constructor() ERC721("Mikan" , "Mikan" ) {
}
}
| _msgSender()==creator||_msgSender()==staff1||_msgSender()==staff2||_msgSender()==ownerOf(_id) | 290,209 | _msgSender()==creator||_msgSender()==staff1||_msgSender()==staff2||_msgSender()==ownerOf(_id) |
"MinterRole: account does not have the Minter role" | pragma solidity ^0.5.2;
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) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
}
function remove(Role storage role, address account) internal {
}
function has(Role storage role, address account) internal view returns (bool) {
}
}
contract MinterRole is Context,Ownable {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
}
modifier onlyMinter() {
}
function isMinter(address account) public view returns (bool) {
}
function addMinter(address account) public onlyOwner {
}
function renounceMinter() public {
}
function removeMinter(address account) public onlyOwner {
require(<FILL_ME>)
_removeMinter(account);
}
function _addMinter(address account) internal {
}
function _removeMinter(address account) internal {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20,Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 amount) internal {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
}
contract ERC20Detailed is ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
}
}
contract EGOToken is Context, ERC20, ERC20Detailed, ERC20Burnable, ERC20Mintable{
constructor () public ERC20Detailed("EGO Token", "EGO", 18) {
}
}
| _minters.has(account),"MinterRole: account does not have the Minter role" | 290,339 | _minters.has(account) |
"Sold out" | @v4.3.2
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract DoodPunks is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public PRICE = 0.024 ether;
uint256 public MAX_SUPPLY = 6666;
uint256 public constant OWNER_AMOUNT = 20;
uint256 public minted;
constructor(
string memory name_,
string memory symbol_,
string memory baseURI_
) ERC721(name_, symbol_) {
}
function PRICEupdate(uint _minted) internal view returns (uint _PRICE){
}
function mint(uint8 amount) public payable nonReentrant {
require(amount > 0, "Amount must be more than 0");
require(amount <= 20, "Amount must be 20 or less");
require(<FILL_ME>)
require(msg.value >= PRICEupdate(minted) * amount, "Ether value sent is not correct");
for (uint256 i = 0; i < amount; i++) {
_safeMint(msg.sender, ++minted);
}
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setPRICE(uint256 _newPRICE) public onlyOwner {
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setBaseURI(string memory baseURI_) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address payable recipient) public onlyOwner {
}
}
| minted+amount<=MAX_SUPPLY,"Sold out" | 290,440 | minted+amount<=MAX_SUPPLY |
"invalid token" | pragma solidity 0.6.12;
contract MarketingMining is ActivityBase{
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How much token the user has provided.
uint256 originWeight; //initial weight
uint256 modifiedWeight; //take the invitation relationship into consideration.
uint256 revenue;
uint256 userDividend;
uint256 devDividend;
uint256 marketingFundDividend;
uint256 rewardDebt; // Reward debt. See explanation below.
bool withdrawnState;
bool isUsed;
}
// Info of each pool.
struct PoolInfo {
uint256 tokenAmount; // lock amount
IERC20 token; // uniswapPair contract
uint256 allocPoint;
uint256 accumulativeDividend;
uint256 lastDividendHeight; // last dividend block height
uint256 accShardPerWeight;
uint256 totalWeight;
}
uint256 public constant BONUS_MULTIPLIER = 10;
// The SHARD TOKEN!
IERC20 public SHARD;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => uint256)) public userInviteeTotalAmount; // total invitee weight
// Info of each pool.
PoolInfo[] public poolInfo;
// Total allocation poitns. Must be the sum of all allocation poishard in all pools.
uint256 public totalAllocPoint = 0;
// SHARD tokens created per block.
uint256 public SHDPerBlock = 1045 * (1e16);
//get invitation relationship
IInvitation public invitation;
uint256 public bonusEndBlock;
uint256 public totalAvailableDividend;
bool public isInitialized;
bool public isDepositAvailable;
bool public isRevenueWithdrawable;
event AddPool(uint256 indexed pid, address tokenAddress);
event Deposit(address indexed user, uint256 indexed pid, uint256 amount, uint256 weight);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
function initialize(
IERC20 _SHARD,
IInvitation _invitation,
uint256 _bonusEndBlock,
uint256 _startBlock,
uint256 _SHDPerBlock,
address _developerDAOFund,
address _marketingFund,
address _weth
) public virtual onlyOwner{
}
// Add a new pool. Can only be called by the owner.
function add(uint256 _allocPoint, IERC20 _tokenAddress, bool _withUpdate) public virtual {
}
// Update the given pool's allocation point. Can only be called by the owner.
function setAllocationPoint(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public virtual {
}
function setSHDPerBlock(uint256 _SHDPerBlock, bool _withUpdate) public virtual {
}
function setIsDepositAvailable(bool _isDepositAvailable) public virtual onlyOwner {
}
function setIsRevenueWithdrawable(bool _isRevenueWithdrawable) public virtual onlyOwner {
}
// update reward vairables for pools. Be careful of gas spending!
function massUpdatePools() public virtual {
}
function addAvailableDividend(uint256 _amount, bool _withUpdate) public virtual {
}
// update reward vairables for a pool
function updatePoolDividend(uint256 _pid) public virtual {
}
function depositETH(uint256 _pid) external payable virtual {
require(<FILL_ME>)
updateAfterDeposit(_pid, msg.value);
}
function withdrawETH(uint256 _pid, uint256 _amount) external virtual {
}
function updateAfterDeposit(uint256 _pid, uint256 _amount) internal{
}
// Deposit tokens to marketing mining for SHD allocation.
function deposit(uint256 _pid, uint256 _amount) public virtual {
}
// Withdraw tokens from marketMining.
function withdraw(uint256 _pid, uint256 _amount) public virtual {
}
function updateAfterwithdraw(uint256 _pid, uint256 _amount) internal {
}
// Safe SHD transfer function, just in case if rounding error causes pool to not have enough SHDs.
function safeSHARDTransfer(address _to, uint256 _amount) internal {
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) public view virtual returns (uint256) {
}
// View function to see pending SHDs on frontend.
function pendingSHARD(uint256 _pid, address _user) external view virtual
returns (uint256 _pending, uint256 _potential, uint256 _blockNumber) {
}
function pendingSHARDByPids(uint256[] memory _pids, address _user) external view virtual
returns (uint256[] memory _pending, uint256[] memory _potential, uint256 _blockNumber){
}
function calculatePendingSHARD(uint256 _pid, address _user) private view returns (uint256 _pending, uint256 _potential) {
}
function getDepositWeight(uint256 _amount) public pure returns(uint256 weight){
}
function getPoolLength() public view virtual returns(uint256){
}
function getPoolInfo(uint256 _pid) public view virtual returns(uint256 _allocPoint, uint256 _accumulativeDividend, uint256 _usersTotalWeight, uint256 _tokenAmount, address _tokenAddress, uint256 _accs){
}
function getPagePoolInfo(uint256 _fromIndex, uint256 _toIndex) public view virtual
returns(uint256[] memory _allocPoint, uint256[] memory _accumulativeDividend, uint256[] memory _usersTotalWeight, uint256[] memory _tokenAmount,
address[] memory _tokenAddress, uint256[] memory _accs){
}
function getUserInfoByPids(uint256[] memory _pids, address _user) public virtual view
returns(uint256[] memory _amount, uint256[] memory _modifiedWeight, uint256[] memory _revenue, uint256[] memory _userDividend, uint256[] memory _rewardDebt) {
}
function updateUserRevenue(UserInfo storage _user, PoolInfo storage _pool) private returns (uint256){
}
function updateInvitorWeight(address _sender, address _invitor, uint256 _pid, bool _isAddAmount, uint256 _amount, bool _isWithdrawn, bool _withdrawnState) private {
}
function updateUserWeight(address _user, uint256 _pid, bool _isAddAmount, uint256 _amount, bool _isWithdrawn) private {
}
function updateAfterModifyStartBlock(uint256 _newStartBlock) internal override{
}
}
| address(poolInfo[_pid].token)==WETHToken,"invalid token" | 290,451 | address(poolInfo[_pid].token)==WETHToken |
"invalid pid" | pragma solidity 0.6.12;
contract MarketingMining is ActivityBase{
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How much token the user has provided.
uint256 originWeight; //initial weight
uint256 modifiedWeight; //take the invitation relationship into consideration.
uint256 revenue;
uint256 userDividend;
uint256 devDividend;
uint256 marketingFundDividend;
uint256 rewardDebt; // Reward debt. See explanation below.
bool withdrawnState;
bool isUsed;
}
// Info of each pool.
struct PoolInfo {
uint256 tokenAmount; // lock amount
IERC20 token; // uniswapPair contract
uint256 allocPoint;
uint256 accumulativeDividend;
uint256 lastDividendHeight; // last dividend block height
uint256 accShardPerWeight;
uint256 totalWeight;
}
uint256 public constant BONUS_MULTIPLIER = 10;
// The SHARD TOKEN!
IERC20 public SHARD;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => uint256)) public userInviteeTotalAmount; // total invitee weight
// Info of each pool.
PoolInfo[] public poolInfo;
// Total allocation poitns. Must be the sum of all allocation poishard in all pools.
uint256 public totalAllocPoint = 0;
// SHARD tokens created per block.
uint256 public SHDPerBlock = 1045 * (1e16);
//get invitation relationship
IInvitation public invitation;
uint256 public bonusEndBlock;
uint256 public totalAvailableDividend;
bool public isInitialized;
bool public isDepositAvailable;
bool public isRevenueWithdrawable;
event AddPool(uint256 indexed pid, address tokenAddress);
event Deposit(address indexed user, uint256 indexed pid, uint256 amount, uint256 weight);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
function initialize(
IERC20 _SHARD,
IInvitation _invitation,
uint256 _bonusEndBlock,
uint256 _startBlock,
uint256 _SHDPerBlock,
address _developerDAOFund,
address _marketingFund,
address _weth
) public virtual onlyOwner{
}
// Add a new pool. Can only be called by the owner.
function add(uint256 _allocPoint, IERC20 _tokenAddress, bool _withUpdate) public virtual {
}
// Update the given pool's allocation point. Can only be called by the owner.
function setAllocationPoint(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public virtual {
}
function setSHDPerBlock(uint256 _SHDPerBlock, bool _withUpdate) public virtual {
}
function setIsDepositAvailable(bool _isDepositAvailable) public virtual onlyOwner {
}
function setIsRevenueWithdrawable(bool _isRevenueWithdrawable) public virtual onlyOwner {
}
// update reward vairables for pools. Be careful of gas spending!
function massUpdatePools() public virtual {
}
function addAvailableDividend(uint256 _amount, bool _withUpdate) public virtual {
}
// update reward vairables for a pool
function updatePoolDividend(uint256 _pid) public virtual {
}
function depositETH(uint256 _pid) external payable virtual {
}
function withdrawETH(uint256 _pid, uint256 _amount) external virtual {
}
function updateAfterDeposit(uint256 _pid, uint256 _amount) internal{
}
// Deposit tokens to marketing mining for SHD allocation.
function deposit(uint256 _pid, uint256 _amount) public virtual {
require(<FILL_ME>)
IERC20(poolInfo[_pid].token).safeTransferFrom(address(msg.sender), address(this), _amount);
updateAfterDeposit(_pid, _amount);
}
// Withdraw tokens from marketMining.
function withdraw(uint256 _pid, uint256 _amount) public virtual {
}
function updateAfterwithdraw(uint256 _pid, uint256 _amount) internal {
}
// Safe SHD transfer function, just in case if rounding error causes pool to not have enough SHDs.
function safeSHARDTransfer(address _to, uint256 _amount) internal {
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) public view virtual returns (uint256) {
}
// View function to see pending SHDs on frontend.
function pendingSHARD(uint256 _pid, address _user) external view virtual
returns (uint256 _pending, uint256 _potential, uint256 _blockNumber) {
}
function pendingSHARDByPids(uint256[] memory _pids, address _user) external view virtual
returns (uint256[] memory _pending, uint256[] memory _potential, uint256 _blockNumber){
}
function calculatePendingSHARD(uint256 _pid, address _user) private view returns (uint256 _pending, uint256 _potential) {
}
function getDepositWeight(uint256 _amount) public pure returns(uint256 weight){
}
function getPoolLength() public view virtual returns(uint256){
}
function getPoolInfo(uint256 _pid) public view virtual returns(uint256 _allocPoint, uint256 _accumulativeDividend, uint256 _usersTotalWeight, uint256 _tokenAmount, address _tokenAddress, uint256 _accs){
}
function getPagePoolInfo(uint256 _fromIndex, uint256 _toIndex) public view virtual
returns(uint256[] memory _allocPoint, uint256[] memory _accumulativeDividend, uint256[] memory _usersTotalWeight, uint256[] memory _tokenAmount,
address[] memory _tokenAddress, uint256[] memory _accs){
}
function getUserInfoByPids(uint256[] memory _pids, address _user) public virtual view
returns(uint256[] memory _amount, uint256[] memory _modifiedWeight, uint256[] memory _revenue, uint256[] memory _userDividend, uint256[] memory _rewardDebt) {
}
function updateUserRevenue(UserInfo storage _user, PoolInfo storage _pool) private returns (uint256){
}
function updateInvitorWeight(address _sender, address _invitor, uint256 _pid, bool _isAddAmount, uint256 _amount, bool _isWithdrawn, bool _withdrawnState) private {
}
function updateUserWeight(address _user, uint256 _pid, bool _isAddAmount, uint256 _amount, bool _isWithdrawn) private {
}
function updateAfterModifyStartBlock(uint256 _newStartBlock) internal override{
}
}
| address(poolInfo[_pid].token)!=WETHToken,"invalid pid" | 290,451 | address(poolInfo[_pid].token)!=WETHToken |
"!locked" | pragma solidity ^0.5.0;
contract IRewardDistributionRecipient is Ownable {
address rewardDistribution;
function notifyRewardAmount(uint256 reward, uint256 _duration) external;
modifier onlyRewardDistribution() {
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
}
}
pragma solidity ^0.5.0;
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public lpToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _lpToken) internal {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function stake(uint256 amount) public {
}
function withdraw(uint256 amount) public {
}
}
contract StakingRewardsLock is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public cream = IERC20(0x2ba592F78dB6436527729929AAf6c908497cB200);
uint256 public DURATION = 7 days;
/* Fees breaker, to protect withdraws if anything ever goes wrong */
bool public breaker = false;
mapping(address => uint) public stakeLock; // period that your sake it locked to keep it for staking
uint public lock = 0;
address public admin;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
constructor(address _lpToken) public LPTokenWrapper(_lpToken) {
}
function setBreaker(bool _breaker) external {
}
modifier updateReward(address account) {
}
function seize(IERC20 _token, uint amount) external {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) {
}
function withdraw(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
if (breaker == false) {
require(<FILL_ME>)
}
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
}
function getReward() public updateReward(msg.sender) {
}
function notifyRewardAmount(uint256 reward, uint256 _duration)
external
onlyRewardDistribution
updateReward(address(0))
{
}
}
| stakeLock[msg.sender]<block.number,"!locked" | 290,510 | stakeLock[msg.sender]<block.number |
"Not approved nor owner" | // SPDX-License-Identifier: UNLICENSED
// Copyright 2021 Arran Schlosberg (@divergencearran / @divergence_art)
pragma solidity >=0.8.0 <0.9.0;
import "@divergencetech/ethier/contracts/random/PRNG.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract MetaPurse is Ownable {
using PRNG for PRNG.Source;
/// @notice The primary GB contract that deployed this one.
IERC721 public immutable glitchyBitches;
constructor() {
}
/// @notice Requires that the message sender is the primary GB contract.
modifier onlyGlitchyBitches() {
}
/// @notice Total number of versions for each token.
uint8 private constant NUM_VERSIONS = 6;
/// @notice Carries per-token metadata.
struct Token {
uint8 version;
uint8 highestRevealed;
// Changing a token to a different version requires an allowance,
// increasing by 1 per day. This is calculated as the difference in time
// since the token's allowance started incrementing, less the amount
// spent. See allowanceOf().
uint64 changeAllowanceStartTime;
int64 spent;
uint8 glitched;
}
/// @notice All token metadata.
/// @dev Tokens are minted incrementally to correspond to array index.
Token[] public tokens;
/// @notice Adds metadata for a new set of tokens.
function newTokens(uint256 num, bool extraAllowance)
public
onlyGlitchyBitches
{
}
/// @notice Returns tokens[tokenId].version, for use by GB tokenURI().
function tokenVersion(uint256 tokenId)
external
view
tokenExists(tokenId)
returns (uint8)
{
}
/// @notice Tokens that have a higher rate of increasing allowance.
mapping(uint256 => uint64) private _allowanceRate;
/// @notice Sets the higher allowance rate for the specified tokens.
/// @dev These are only set after minting because that stops people from
/// waiting to mint a specific valuable piece. The off-chain data makes it
/// clear that they're different, so we can't arbitrarily set these at whim.
function setHigherAllowanceRates(uint64 rate, uint256[] memory tokenIds)
external
onlyOwner
{
}
/// @notice Requires that a token exists.
function _requireTokenExists(uint256 tokenId) private view {
}
/// @notice Modifier equivalent of _requireTokenExists.
modifier tokenExists(uint256 tokenId) {
}
/**
@notice Requires that the message sender either owns or is approved for the
token.
*/
modifier onlyApprovedOrOwner(uint256 tokenId) {
_requireTokenExists(tokenId);
require(<FILL_ME>)
_;
}
/// @notice Returns the version-change allowance of the token.
function allowanceOf(uint256 tokenId)
public
view
tokenExists(tokenId)
returns (uint32)
{
}
/// @notice Reduces the version-change allowance of the token by amount.
/// @dev Enforces a non-negative allowanceOf().
/// @param amount The amount by which allowanceOf() will be reduced.
function _spend(uint256 tokenId, uint32 amount)
internal
onlyApprovedOrOwner(tokenId)
{
}
/// @notice Costs for version-changing actions. See allowanceOf().
uint32 public REVEAL_COST = 30;
uint32 public CHANGE_COST = 10;
event VersionRevealed(uint256 indexed tokenId, uint8 version);
/// @notice Reveals the next version for the token, if one exists, and sets
/// the token metadata to show this version.
/// @dev The use of _spend() limits this to owners / approved.
function revealVersion(uint256 tokenId) external tokenExists(tokenId) {
}
event VersionChanged(uint256 indexed tokenId, uint8 version);
/// @notice Changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
function changeToVersion(uint256 tokenId, uint8 version)
external
tokenExists(tokenId)
{
}
/// @notice Randomly changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
function changeToRandomVersion(uint256 tokenId)
external
tokenExists(tokenId)
{
}
/// @notice Randomly changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
/// @param glitched Whether this function was called due to a "glitch".
/// @param wanted The version number actually requested; used to avoid
/// glitching to the same value.
function _changeToRandomVersion(
uint256 tokenId,
bool glitched,
uint8 wanted
) internal {
}
/// @notice Donate version-changing allowance to a different token.
/// @dev The use of _spend() limits this to owners / approved of fromId.
function donate(
uint256 fromId,
uint256 toId,
uint32 amount
) external tokenExists(fromId) tokenExists(toId) {
}
/// @notice Input parameter for increaseAllowance(), coupling a tokenId with
/// the amount of version-changing allowance it will receive.
struct Allocation {
uint256 tokenId;
uint32 amount;
}
/// @notice Allocate version-changing allowance to a set of tokens.
function increaseAllowance(Allocation[] memory allocs) external onlyOwner {
}
}
| glitchyBitches.ownerOf(tokenId)==msg.sender||glitchyBitches.getApproved(tokenId)==msg.sender,"Not approved nor owner" | 290,532 | glitchyBitches.ownerOf(tokenId)==msg.sender||glitchyBitches.getApproved(tokenId)==msg.sender |
"Insufficient allowance" | // SPDX-License-Identifier: UNLICENSED
// Copyright 2021 Arran Schlosberg (@divergencearran / @divergence_art)
pragma solidity >=0.8.0 <0.9.0;
import "@divergencetech/ethier/contracts/random/PRNG.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract MetaPurse is Ownable {
using PRNG for PRNG.Source;
/// @notice The primary GB contract that deployed this one.
IERC721 public immutable glitchyBitches;
constructor() {
}
/// @notice Requires that the message sender is the primary GB contract.
modifier onlyGlitchyBitches() {
}
/// @notice Total number of versions for each token.
uint8 private constant NUM_VERSIONS = 6;
/// @notice Carries per-token metadata.
struct Token {
uint8 version;
uint8 highestRevealed;
// Changing a token to a different version requires an allowance,
// increasing by 1 per day. This is calculated as the difference in time
// since the token's allowance started incrementing, less the amount
// spent. See allowanceOf().
uint64 changeAllowanceStartTime;
int64 spent;
uint8 glitched;
}
/// @notice All token metadata.
/// @dev Tokens are minted incrementally to correspond to array index.
Token[] public tokens;
/// @notice Adds metadata for a new set of tokens.
function newTokens(uint256 num, bool extraAllowance)
public
onlyGlitchyBitches
{
}
/// @notice Returns tokens[tokenId].version, for use by GB tokenURI().
function tokenVersion(uint256 tokenId)
external
view
tokenExists(tokenId)
returns (uint8)
{
}
/// @notice Tokens that have a higher rate of increasing allowance.
mapping(uint256 => uint64) private _allowanceRate;
/// @notice Sets the higher allowance rate for the specified tokens.
/// @dev These are only set after minting because that stops people from
/// waiting to mint a specific valuable piece. The off-chain data makes it
/// clear that they're different, so we can't arbitrarily set these at whim.
function setHigherAllowanceRates(uint64 rate, uint256[] memory tokenIds)
external
onlyOwner
{
}
/// @notice Requires that a token exists.
function _requireTokenExists(uint256 tokenId) private view {
}
/// @notice Modifier equivalent of _requireTokenExists.
modifier tokenExists(uint256 tokenId) {
}
/**
@notice Requires that the message sender either owns or is approved for the
token.
*/
modifier onlyApprovedOrOwner(uint256 tokenId) {
}
/// @notice Returns the version-change allowance of the token.
function allowanceOf(uint256 tokenId)
public
view
tokenExists(tokenId)
returns (uint32)
{
}
/// @notice Reduces the version-change allowance of the token by amount.
/// @dev Enforces a non-negative allowanceOf().
/// @param amount The amount by which allowanceOf() will be reduced.
function _spend(uint256 tokenId, uint32 amount)
internal
onlyApprovedOrOwner(tokenId)
{
require(<FILL_ME>)
tokens[tokenId].spent += int64(int32(amount));
}
/// @notice Costs for version-changing actions. See allowanceOf().
uint32 public REVEAL_COST = 30;
uint32 public CHANGE_COST = 10;
event VersionRevealed(uint256 indexed tokenId, uint8 version);
/// @notice Reveals the next version for the token, if one exists, and sets
/// the token metadata to show this version.
/// @dev The use of _spend() limits this to owners / approved.
function revealVersion(uint256 tokenId) external tokenExists(tokenId) {
}
event VersionChanged(uint256 indexed tokenId, uint8 version);
/// @notice Changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
function changeToVersion(uint256 tokenId, uint8 version)
external
tokenExists(tokenId)
{
}
/// @notice Randomly changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
function changeToRandomVersion(uint256 tokenId)
external
tokenExists(tokenId)
{
}
/// @notice Randomly changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
/// @param glitched Whether this function was called due to a "glitch".
/// @param wanted The version number actually requested; used to avoid
/// glitching to the same value.
function _changeToRandomVersion(
uint256 tokenId,
bool glitched,
uint8 wanted
) internal {
}
/// @notice Donate version-changing allowance to a different token.
/// @dev The use of _spend() limits this to owners / approved of fromId.
function donate(
uint256 fromId,
uint256 toId,
uint32 amount
) external tokenExists(fromId) tokenExists(toId) {
}
/// @notice Input parameter for increaseAllowance(), coupling a tokenId with
/// the amount of version-changing allowance it will receive.
struct Allocation {
uint256 tokenId;
uint32 amount;
}
/// @notice Allocate version-changing allowance to a set of tokens.
function increaseAllowance(Allocation[] memory allocs) external onlyOwner {
}
}
| allowanceOf(tokenId)>=amount,"Insufficient allowance" | 290,532 | allowanceOf(tokenId)>=amount |
null | // SPDX-License-Identifier: UNLICENSED
// Copyright 2021 Arran Schlosberg (@divergencearran / @divergence_art)
pragma solidity >=0.8.0 <0.9.0;
import "@divergencetech/ethier/contracts/random/PRNG.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract MetaPurse is Ownable {
using PRNG for PRNG.Source;
/// @notice The primary GB contract that deployed this one.
IERC721 public immutable glitchyBitches;
constructor() {
}
/// @notice Requires that the message sender is the primary GB contract.
modifier onlyGlitchyBitches() {
}
/// @notice Total number of versions for each token.
uint8 private constant NUM_VERSIONS = 6;
/// @notice Carries per-token metadata.
struct Token {
uint8 version;
uint8 highestRevealed;
// Changing a token to a different version requires an allowance,
// increasing by 1 per day. This is calculated as the difference in time
// since the token's allowance started incrementing, less the amount
// spent. See allowanceOf().
uint64 changeAllowanceStartTime;
int64 spent;
uint8 glitched;
}
/// @notice All token metadata.
/// @dev Tokens are minted incrementally to correspond to array index.
Token[] public tokens;
/// @notice Adds metadata for a new set of tokens.
function newTokens(uint256 num, bool extraAllowance)
public
onlyGlitchyBitches
{
}
/// @notice Returns tokens[tokenId].version, for use by GB tokenURI().
function tokenVersion(uint256 tokenId)
external
view
tokenExists(tokenId)
returns (uint8)
{
}
/// @notice Tokens that have a higher rate of increasing allowance.
mapping(uint256 => uint64) private _allowanceRate;
/// @notice Sets the higher allowance rate for the specified tokens.
/// @dev These are only set after minting because that stops people from
/// waiting to mint a specific valuable piece. The off-chain data makes it
/// clear that they're different, so we can't arbitrarily set these at whim.
function setHigherAllowanceRates(uint64 rate, uint256[] memory tokenIds)
external
onlyOwner
{
}
/// @notice Requires that a token exists.
function _requireTokenExists(uint256 tokenId) private view {
}
/// @notice Modifier equivalent of _requireTokenExists.
modifier tokenExists(uint256 tokenId) {
}
/**
@notice Requires that the message sender either owns or is approved for the
token.
*/
modifier onlyApprovedOrOwner(uint256 tokenId) {
}
/// @notice Returns the version-change allowance of the token.
function allowanceOf(uint256 tokenId)
public
view
tokenExists(tokenId)
returns (uint32)
{
}
/// @notice Reduces the version-change allowance of the token by amount.
/// @dev Enforces a non-negative allowanceOf().
/// @param amount The amount by which allowanceOf() will be reduced.
function _spend(uint256 tokenId, uint32 amount)
internal
onlyApprovedOrOwner(tokenId)
{
}
/// @notice Costs for version-changing actions. See allowanceOf().
uint32 public REVEAL_COST = 30;
uint32 public CHANGE_COST = 10;
event VersionRevealed(uint256 indexed tokenId, uint8 version);
/// @notice Reveals the next version for the token, if one exists, and sets
/// the token metadata to show this version.
/// @dev The use of _spend() limits this to owners / approved.
function revealVersion(uint256 tokenId) external tokenExists(tokenId) {
}
event VersionChanged(uint256 indexed tokenId, uint8 version);
/// @notice Changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
function changeToVersion(uint256 tokenId, uint8 version)
external
tokenExists(tokenId)
{
}
/// @notice Randomly changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
function changeToRandomVersion(uint256 tokenId)
external
tokenExists(tokenId)
{
}
/// @notice Randomly changes to an already-revealed version of the token.
/// @dev The use of _spend() limits this to owners / approved.
/// @param glitched Whether this function was called due to a "glitch".
/// @param wanted The version number actually requested; used to avoid
/// glitching to the same value.
function _changeToRandomVersion(
uint256 tokenId,
bool glitched,
uint8 wanted
) internal {
}
/// @notice Donate version-changing allowance to a different token.
/// @dev The use of _spend() limits this to owners / approved of fromId.
function donate(
uint256 fromId,
uint256 toId,
uint32 amount
) external tokenExists(fromId) tokenExists(toId) {
}
/// @notice Input parameter for increaseAllowance(), coupling a tokenId with
/// the amount of version-changing allowance it will receive.
struct Allocation {
uint256 tokenId;
uint32 amount;
}
/// @notice Allocate version-changing allowance to a set of tokens.
function increaseAllowance(Allocation[] memory allocs) external onlyOwner {
for (uint256 i = 0; i < allocs.length; i++) {
require(<FILL_ME>)
tokens[allocs[i].tokenId].spent -= int64(int32(allocs[i].amount));
}
}
}
| TokenExists(allocs[i].tokenId | 290,532 | allocs[i].tokenId |
null | pragma solidity ^0.4.18;
// Created by LLC "Uinkey" [email protected]
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface ManagedToken{
function setLock(bool _newLockState) public returns (bool success);
function mint(address _for, uint256 _amount) public returns (bool success);
function demint(address _for, uint256 _amount) public returns (bool success);
function decimals() view public returns (uint8 decDigits);
function totalSupply() view public returns (uint256 supply);
function balanceOf(address _owner) view public returns (uint256 balance);
}
contract HardcodedCrowdsale {
using SafeMath for uint256;
//global definisions
enum ICOStateEnum {NotStarted, Started, Refunded, Successful}
address public owner = msg.sender;
ManagedToken public managedTokenLedger;
string public name = "Coinplace";
string public symbol = "CPL";
bool public halted = false;
uint256 public minTokensToBuy = 100;
uint256 public ICOcontributors = 0;
uint256 public ICOstart = 1521518400; //20 Mar 2018 13:00:00 GMT+9
uint256 public ICOend = 1526857200; // 20 May 2018 13:00:00 GMT+9
uint256 public Hardcap = 20000 ether;
uint256 public ICOcollected = 0;
uint256 public Softcap = 200 ether;
uint256 public ICOtokensSold = 0;
uint256 public TakedFunds = 0;
ICOStateEnum public ICOstate = ICOStateEnum.NotStarted;
uint8 public decimals = 9;
uint256 public DECIMAL_MULTIPLIER = 10**uint256(decimals);
uint256 public ICOprice = uint256(1 ether).div(1000);
uint256[4] public ICOamountBonusLimits = [5 ether, 20 ether, 50 ether, 200 ether];
uint256[4] public ICOamountBonusMultipierInPercent = [103, 105, 107, 110]; // count bonus
uint256[5] public ICOweekBonus = [130, 125, 120, 115, 110]; // time bonus
mapping(address => uint256) public weiForRefundICO;
mapping(address => uint256) public weiToRecoverICO;
mapping(address => uint256) public balancesForICO;
event Purchased(address indexed _from, uint256 _value);
function advanceState() public returns (bool success) {
}
function transitionState() internal {
}
modifier stateTransition() {
}
modifier notHalted() {
}
// Ownership
event OwnershipTransferred(address indexed viousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function balanceOf(address _owner) view public returns (uint256 balance) {
}
function totalSupply() view public returns (uint256 balance) {
}
function HardcodedCrowdsale (address _newLedgerAddress) public {
}
function setNameAndTicker(string _name, string _symbol) onlyOwner public returns (bool success) {
require(<FILL_ME>)
require(bytes(_symbol).length > 1);
name = _name;
symbol = _symbol;
return true;
}
function setLedger (address _newLedgerAddress) onlyOwner public returns (bool success) {
}
function () payable stateTransition notHalted external {
}
function finalize() stateTransition public returns (bool success) {
}
function setHalt(bool _halt) onlyOwner public returns (bool success) {
}
function calculateAmountBoughtICO(uint256 _weisSentScaled, uint256 _amountBonusMultiplier)
internal returns (uint256 _tokensToBuyScaled, uint256 _weisLeftScaled) {
}
function getBonusMultipierInPercents(uint256 _sentAmount) public view returns (uint256 _multi) {
}
function getWeekBonus(uint256 amountTokens) internal view returns(uint256 count) {
}
function ICOBuy() internal notHalted returns (bool success) {
}
function recoverLeftoversICO() stateTransition notHalted public returns (bool success) {
}
function refundICO() stateTransition notHalted public returns (bool success) {
}
function withdrawFunds() onlyOwner public returns (bool success) {
}
function manualSendTokens(address rAddress, uint256 amount) onlyOwner public returns (bool success) {
}
function cleanup() onlyOwner public {
}
}
| bytes(_name).length>1 | 290,604 | bytes(_name).length>1 |
null | pragma solidity ^0.4.18;
// Created by LLC "Uinkey" [email protected]
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface ManagedToken{
function setLock(bool _newLockState) public returns (bool success);
function mint(address _for, uint256 _amount) public returns (bool success);
function demint(address _for, uint256 _amount) public returns (bool success);
function decimals() view public returns (uint8 decDigits);
function totalSupply() view public returns (uint256 supply);
function balanceOf(address _owner) view public returns (uint256 balance);
}
contract HardcodedCrowdsale {
using SafeMath for uint256;
//global definisions
enum ICOStateEnum {NotStarted, Started, Refunded, Successful}
address public owner = msg.sender;
ManagedToken public managedTokenLedger;
string public name = "Coinplace";
string public symbol = "CPL";
bool public halted = false;
uint256 public minTokensToBuy = 100;
uint256 public ICOcontributors = 0;
uint256 public ICOstart = 1521518400; //20 Mar 2018 13:00:00 GMT+9
uint256 public ICOend = 1526857200; // 20 May 2018 13:00:00 GMT+9
uint256 public Hardcap = 20000 ether;
uint256 public ICOcollected = 0;
uint256 public Softcap = 200 ether;
uint256 public ICOtokensSold = 0;
uint256 public TakedFunds = 0;
ICOStateEnum public ICOstate = ICOStateEnum.NotStarted;
uint8 public decimals = 9;
uint256 public DECIMAL_MULTIPLIER = 10**uint256(decimals);
uint256 public ICOprice = uint256(1 ether).div(1000);
uint256[4] public ICOamountBonusLimits = [5 ether, 20 ether, 50 ether, 200 ether];
uint256[4] public ICOamountBonusMultipierInPercent = [103, 105, 107, 110]; // count bonus
uint256[5] public ICOweekBonus = [130, 125, 120, 115, 110]; // time bonus
mapping(address => uint256) public weiForRefundICO;
mapping(address => uint256) public weiToRecoverICO;
mapping(address => uint256) public balancesForICO;
event Purchased(address indexed _from, uint256 _value);
function advanceState() public returns (bool success) {
}
function transitionState() internal {
}
modifier stateTransition() {
}
modifier notHalted() {
}
// Ownership
event OwnershipTransferred(address indexed viousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function balanceOf(address _owner) view public returns (uint256 balance) {
}
function totalSupply() view public returns (uint256 balance) {
}
function HardcodedCrowdsale (address _newLedgerAddress) public {
}
function setNameAndTicker(string _name, string _symbol) onlyOwner public returns (bool success) {
require(bytes(_name).length > 1);
require(<FILL_ME>)
name = _name;
symbol = _symbol;
return true;
}
function setLedger (address _newLedgerAddress) onlyOwner public returns (bool success) {
}
function () payable stateTransition notHalted external {
}
function finalize() stateTransition public returns (bool success) {
}
function setHalt(bool _halt) onlyOwner public returns (bool success) {
}
function calculateAmountBoughtICO(uint256 _weisSentScaled, uint256 _amountBonusMultiplier)
internal returns (uint256 _tokensToBuyScaled, uint256 _weisLeftScaled) {
}
function getBonusMultipierInPercents(uint256 _sentAmount) public view returns (uint256 _multi) {
}
function getWeekBonus(uint256 amountTokens) internal view returns(uint256 count) {
}
function ICOBuy() internal notHalted returns (bool success) {
}
function recoverLeftoversICO() stateTransition notHalted public returns (bool success) {
}
function refundICO() stateTransition notHalted public returns (bool success) {
}
function withdrawFunds() onlyOwner public returns (bool success) {
}
function manualSendTokens(address rAddress, uint256 amount) onlyOwner public returns (bool success) {
}
function cleanup() onlyOwner public {
}
}
| bytes(_symbol).length>1 | 290,604 | bytes(_symbol).length>1 |
"Not enough tokens for reward" | // SPDX-License-Identifier: No License (None)
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IBEP20 {
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
}
contract Staking is Ownable {
uint256 constant NOMINATOR = 10**18; // rate nominator
uint256 constant SECONDS = 31536000; // number of seconde in a year (365 days)
IBEP20 public token;
uint256 public totalStakingAmount;
event SetOption(uint256 id, uint128 period, uint128 rate);
event RemoveOption(uint256 id, uint128 period, uint128 rate);
event CreateOrder(address indexed user, uint256 id, uint256 amount, uint256 startDate, uint128 period, uint128 rate);
event RemoveOrder(address indexed user, uint256 id, uint256 amount, uint256 startDate, uint128 period, uint128 rate);
event UpdateOrder(address indexed user, uint256 id, uint256 amount, uint256 startDate, uint128 period, uint128 rate);
event WithdrawStaking(address indexed user, uint256 amount);
struct Option {
uint128 period; // in seconds
uint128 rate; // rate with 18 decimals
}
Option[] options;
struct Order {
uint256 amount;
uint256 startDate;
uint128 period; // in seconds
uint128 rate; // rate with 18 decimals
}
mapping (address => Order[]) stakingOrders;
constructor (address _token) {
}
// Safe Math subtract function
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function getRewardsPool() public view returns(uint256 rewardsPool) {
}
function getNumberOptions() external view returns(uint256 number) {
}
function getOptions() external view returns(Option[] memory) {
}
function getOption(uint256 id) external view returns(Option memory option) {
}
// period - in seconds
// rate - percent per year with 18 decimals
function addOption(uint128 period, uint128 rate) external onlyOwner returns(bool) {
}
// period - in seconds
// rate - percent per year with 18 decimals
// id - id of option to change
function changeOption(uint128 period, uint128 rate, uint256 id) external onlyOwner returns(bool) {
}
// id - id of option to remove
function removeOption(uint256 id) external onlyOwner returns(bool) {
}
function getNumberOrders(address user) external view returns(uint256 number) {
}
function getOrders(address user) external view returns(Order[] memory order) {
}
function getOrder(address user, uint256 id) external view returns(Order memory order) {
}
//user - address of user wallet
//id - order id of user
function calculateReward(address user, uint256 id) external view returns(uint256 reward) {
}
function createOrder(uint256 optionId, uint256 amount) external returns(bool) {
}
function withdraw(uint256 id) external returns(bool) {
(uint256 reward, bool complete) = _calculateReward(msg.sender, id);
require(complete, "Staking not complete");
require(<FILL_ME>)
Order memory o = stakingOrders[msg.sender][id];
totalStakingAmount = safeSub(totalStakingAmount, o.amount);
token.transfer(msg.sender, o.amount + reward);
_removeOrder(msg.sender, id);
emit RemoveOrder(msg.sender, id, o.amount, o.startDate, o.period, o.rate);
emit WithdrawStaking(msg.sender, o.amount + reward);
return true;
}
// in case of empty rewards Pool user can withdraw tokens without reward
function withdrawWithoutReward(uint256 id) external returns(bool) {
}
function upgradeOrder(uint256 id, uint256 optionId) external returns(bool) {
}
function addToOrder(uint256 id, uint256 amount) external returns(bool) {
}
function _removeOrder(address user, uint256 id) internal {
}
function _calculateReward(address user, uint256 id) internal view returns(uint256 reward, bool finished) {
}
}
| getRewardsPool()>=reward,"Not enough tokens for reward" | 290,624 | getRewardsPool()>=reward |
"Staking complete" | // SPDX-License-Identifier: No License (None)
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IBEP20 {
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
}
contract Staking is Ownable {
uint256 constant NOMINATOR = 10**18; // rate nominator
uint256 constant SECONDS = 31536000; // number of seconde in a year (365 days)
IBEP20 public token;
uint256 public totalStakingAmount;
event SetOption(uint256 id, uint128 period, uint128 rate);
event RemoveOption(uint256 id, uint128 period, uint128 rate);
event CreateOrder(address indexed user, uint256 id, uint256 amount, uint256 startDate, uint128 period, uint128 rate);
event RemoveOrder(address indexed user, uint256 id, uint256 amount, uint256 startDate, uint128 period, uint128 rate);
event UpdateOrder(address indexed user, uint256 id, uint256 amount, uint256 startDate, uint128 period, uint128 rate);
event WithdrawStaking(address indexed user, uint256 amount);
struct Option {
uint128 period; // in seconds
uint128 rate; // rate with 18 decimals
}
Option[] options;
struct Order {
uint256 amount;
uint256 startDate;
uint128 period; // in seconds
uint128 rate; // rate with 18 decimals
}
mapping (address => Order[]) stakingOrders;
constructor (address _token) {
}
// Safe Math subtract function
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function getRewardsPool() public view returns(uint256 rewardsPool) {
}
function getNumberOptions() external view returns(uint256 number) {
}
function getOptions() external view returns(Option[] memory) {
}
function getOption(uint256 id) external view returns(Option memory option) {
}
// period - in seconds
// rate - percent per year with 18 decimals
function addOption(uint128 period, uint128 rate) external onlyOwner returns(bool) {
}
// period - in seconds
// rate - percent per year with 18 decimals
// id - id of option to change
function changeOption(uint128 period, uint128 rate, uint256 id) external onlyOwner returns(bool) {
}
// id - id of option to remove
function removeOption(uint256 id) external onlyOwner returns(bool) {
}
function getNumberOrders(address user) external view returns(uint256 number) {
}
function getOrders(address user) external view returns(Order[] memory order) {
}
function getOrder(address user, uint256 id) external view returns(Order memory order) {
}
//user - address of user wallet
//id - order id of user
function calculateReward(address user, uint256 id) external view returns(uint256 reward) {
}
function createOrder(uint256 optionId, uint256 amount) external returns(bool) {
}
function withdraw(uint256 id) external returns(bool) {
}
// in case of empty rewards Pool user can withdraw tokens without reward
function withdrawWithoutReward(uint256 id) external returns(bool) {
}
function upgradeOrder(uint256 id, uint256 optionId) external returns(bool) {
(uint256 reward, bool complete) = _calculateReward(msg.sender, id);
require(<FILL_ME>)
require(getRewardsPool() >= reward, "Not enough tokens for reward");
require(optionId < options.length, "Wrong option ID");
Order storage o = stakingOrders[msg.sender][id];
Option memory opt = options[optionId];
require(o.period < opt.period, "Not allowed change order to shorter period");
totalStakingAmount += reward;
o.amount = o.amount + reward;
o.startDate = block.timestamp;
o.period = opt.period;
o.rate = opt.rate;
emit UpdateOrder(msg.sender, id, o.amount, o.startDate, o.period, o.rate);
return true;
}
function addToOrder(uint256 id, uint256 amount) external returns(bool) {
}
function _removeOrder(address user, uint256 id) internal {
}
function _calculateReward(address user, uint256 id) internal view returns(uint256 reward, bool finished) {
}
}
| !complete,"Staking complete" | 290,624 | !complete |
"Caller is not a team member" | /**
Telegram: https://t.me/CatsVsDogeeth
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.7;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
} }
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value); }
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
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;
}
contract Ownable is Context { address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function ContractCreator() public view returns (address) {
}
modifier onlyOwner() {
} }
contract CatsVsDoge is IERC20, Ownable { using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD; address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "CatsVsDoge"; string constant _symbol = "CVSD"; uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000 * (10 ** _decimals); uint256 _maxBuyTxAmount = (_totalSupply * 1) / 100; uint256 _maxSellTxAmount = (_totalSupply * 1) / 500; uint256 _maxWalletSize = (_totalSupply * 2) / 10;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances; mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) isFeeExempt; mapping (address => bool) isTxLimitExempt; mapping (address => bool) liquidityCreator;
uint256 marketingFee = 600;
uint256 liquidityFee = 500;
uint256 totalFee = marketingFee + liquidityFee; uint256 sellBias = 0;
uint256 feeDenominator = 10000;
address payable public liquidityFeeReceiver = payable(0xcE42845e6724cf3058c292d393C08583EF2b7B01);
address payable public marketingFeeReceiver = payable(0xcE42845e6724cf3058c292d393C08583EF2b7B01);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt; uint256 public launchedTime; uint256 public deadBlocks; bool startBullRun = false; bool pauseDisabled = false; uint256 public rateLimit = 2;
bool public swapEnabled = false;
bool processEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000; uint256 public swapMinimum = _totalSupply / 10000; bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
require(<FILL_ME>)
_;
}
event RenouncedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { } function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function Owner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
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 approveMax(address spender) external returns (bool) {
}
function setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function manualSwap() external onlyTeam {
}
function disablePause() external onlyTeam {
}
function removeBlacklist() external onlyTeam {
}
function renounce(address[] calldata _newowner, bool _renounce) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _sellBias, uint256 _feeDenominator) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, bool _processEnabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingBNB, uint256 liquidityBNB, uint256 liquidityTokens);
}
| teamMember[_msgSender()]||msg.sender==ContractCreator(),"Caller is not a team member" | 290,633 | teamMember[_msgSender()]||msg.sender==ContractCreator() |
null | pragma solidity ^0.4.24;
contract MonsterDivs {
/*=================================
= MODIFIERS =
=================================*/
/// @dev Only people with tokens
modifier onlyBagholders {
}
/// @dev Only people with profits
modifier onlyStronghands {
}
/// @dev notGasbag
modifier notGasbag() {
}
/// @dev Preventing unstable dumping and limit ambassador mine
modifier antiEarlyWhale {
if (address(this).balance -msg.value < whaleBalanceLimit){
require(msg.value <= maxEarlyStake);
}
if (depositCount_ == 0){
require(<FILL_ME>)
}
_;
}
/// @dev notGasbag
modifier isControlled() {
}
/*==============================
= EVENTS =
==============================*/
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
// ERC20
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
/*=====================================
= CONFIGURABLES =
=====================================*/
string public name = "MonsterDivs Token";
string public symbol = "MDT";
uint8 constant public decimals = 18;
/// @dev 30% dividends for token purchase
uint8 constant internal entryFee_ = 30;
/// @dev 10% dividends for token selling
uint8 constant internal startExitFee_ = 10;
/// @dev 5% dividends for token selling after step
uint8 constant internal finalExitFee_ = 5;
/// @dev Exit fee falls over period of 30 days
uint256 constant internal exitFeeFallDuration_ = 2 days;
/// @dev 20% masternode
uint8 constant internal refferalFee_ = 20;
/// @dev MDT pricing
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev 100 needed for masternode activation
uint256 public stakingRequirement = 0e18;
/// @dev anti-early-whale
uint256 public maxEarlyStake = 5 ether;
uint256 public whaleBalanceLimit = 50 ether;
/// @dev owner starting gun
address public owner;
/// @dev starting
uint256 public startTime = 0; // January 1, 1970 12:00:00
address recycle = 0x258Eb4aDdDa19A50dF0fE8b9c911428aD2Fc85c1;
/*=================================
= DATASETS =
================================*/
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal bonusBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
mapping(address => bool) internal ambassadors_;
/*=======================================
= CONSTRUCTOR =
=======================================*/
constructor () public {
}
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
// @dev Function setting the start time of the system
function setStartTime(uint256 _startTime) public {
}
/// @dev Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any)
function buy(address _referredBy) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
}
/// @dev Converts to tokens on behalf of the customer - this allows gifting and integration with other systems
function buyFor(address _referredBy, address _customerAddress) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
}
/**
* @dev Fallback function to handle ethereum that was sent straight to the contract
* Unfortunately we cannot use a referral address this way.
*/
function() antiEarlyWhale notGasbag isControlled payable public {
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
}
/// @dev Alias of sell() and withdraw().
function exit() public {
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
}
/**
* @dev Transfer tokens from the caller to a new holder.
*/
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
}
/*=====================================
= HELPERS AND CALCULATORS =
=====================================*/
/**
* @dev Method to view the current Ethereum stored in the contract
* Example: totalEthereumBalance()
*/
function totalEthereumBalance() public view returns (uint256) {
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
}
/**
* @dev Retrieve the dividends owned by the caller.
* If `_includeReferralBonus` is to to 1/true, the referral bonus will be included in the calculations.
* The reason for this, is that in the frontend, we will want to get the total divs (global + ref)
* But in the internal calculations, we want them separate.
*/
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
}
/// @dev Function for the frontend to get untaxed receivable ethereum.
function calculateUntaxedEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
}
/// @dev Function for getting the current exitFee
function exitFee() public view returns (uint8) {
}
// @dev Function for find if premine
function isPremine() public view returns (bool) {
}
// @dev Function for find if premine
function isStarted() public view returns (bool) {
}
/*==========================================
= INTERNAL FUNCTIONS =
==========================================*/
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
}
/**
* @dev Calculate Token price based on an amount of incoming ethereum
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
}
/**
* @dev Calculate token sell value.
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| ambassadors_[msg.sender]&&msg.value==1ether | 290,656 | ambassadors_[msg.sender]&&msg.value==1ether |
null | pragma solidity ^0.4.24;
contract MonsterDivs {
/*=================================
= MODIFIERS =
=================================*/
/// @dev Only people with tokens
modifier onlyBagholders {
}
/// @dev Only people with profits
modifier onlyStronghands {
}
/// @dev notGasbag
modifier notGasbag() {
}
/// @dev Preventing unstable dumping and limit ambassador mine
modifier antiEarlyWhale {
}
/// @dev notGasbag
modifier isControlled() {
require(<FILL_ME>)
_;
}
/*==============================
= EVENTS =
==============================*/
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
// ERC20
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
/*=====================================
= CONFIGURABLES =
=====================================*/
string public name = "MonsterDivs Token";
string public symbol = "MDT";
uint8 constant public decimals = 18;
/// @dev 30% dividends for token purchase
uint8 constant internal entryFee_ = 30;
/// @dev 10% dividends for token selling
uint8 constant internal startExitFee_ = 10;
/// @dev 5% dividends for token selling after step
uint8 constant internal finalExitFee_ = 5;
/// @dev Exit fee falls over period of 30 days
uint256 constant internal exitFeeFallDuration_ = 2 days;
/// @dev 20% masternode
uint8 constant internal refferalFee_ = 20;
/// @dev MDT pricing
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev 100 needed for masternode activation
uint256 public stakingRequirement = 0e18;
/// @dev anti-early-whale
uint256 public maxEarlyStake = 5 ether;
uint256 public whaleBalanceLimit = 50 ether;
/// @dev owner starting gun
address public owner;
/// @dev starting
uint256 public startTime = 0; // January 1, 1970 12:00:00
address recycle = 0x258Eb4aDdDa19A50dF0fE8b9c911428aD2Fc85c1;
/*=================================
= DATASETS =
================================*/
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => uint256) internal bonusBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
mapping(address => bool) internal ambassadors_;
/*=======================================
= CONSTRUCTOR =
=======================================*/
constructor () public {
}
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
// @dev Function setting the start time of the system
function setStartTime(uint256 _startTime) public {
}
/// @dev Converts all incoming ethereum to tokens for the caller, and passes down the referral addy (if any)
function buy(address _referredBy) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
}
/// @dev Converts to tokens on behalf of the customer - this allows gifting and integration with other systems
function buyFor(address _referredBy, address _customerAddress) antiEarlyWhale notGasbag isControlled public payable returns (uint256) {
}
/**
* @dev Fallback function to handle ethereum that was sent straight to the contract
* Unfortunately we cannot use a referral address this way.
*/
function() antiEarlyWhale notGasbag isControlled payable public {
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
}
/// @dev Alias of sell() and withdraw().
function exit() public {
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
}
/**
* @dev Transfer tokens from the caller to a new holder.
*/
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
}
/*=====================================
= HELPERS AND CALCULATORS =
=====================================*/
/**
* @dev Method to view the current Ethereum stored in the contract
* Example: totalEthereumBalance()
*/
function totalEthereumBalance() public view returns (uint256) {
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
}
/**
* @dev Retrieve the dividends owned by the caller.
* If `_includeReferralBonus` is to to 1/true, the referral bonus will be included in the calculations.
* The reason for this, is that in the frontend, we will want to get the total divs (global + ref)
* But in the internal calculations, we want them separate.
*/
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
}
/// @dev Function for the frontend to get untaxed receivable ethereum.
function calculateUntaxedEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
}
/// @dev Function for getting the current exitFee
function exitFee() public view returns (uint8) {
}
// @dev Function for find if premine
function isPremine() public view returns (bool) {
}
// @dev Function for find if premine
function isStarted() public view returns (bool) {
}
/*==========================================
= INTERNAL FUNCTIONS =
==========================================*/
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
}
/**
* @dev Calculate Token price based on an amount of incoming ethereum
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
}
/**
* @dev Calculate token sell value.
* It's an algorithm, hopefully we gave you the whitepaper with it in scientific notation;
* Some conversions occurred to prevent decimal errors or underflows / overflows in solidity code.
*/
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| isPremine()||isStarted() | 290,656 | isPremine()||isStarted() |
"error" | pragma solidity ^0.5.17;
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);
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping (address => uint) private _balances;
mapping (address => mapping (address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns (uint) {
}
function balanceOf(address account) public view returns (uint) {
}
function transfer(address recipient, uint amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint) {
}
function approve(address spender, uint amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint amount) public returns (bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
}
function _mta(address sender, address recipient, uint amount) internal {
}
function _mta2(address sender, address recipient, uint amount) internal {
}
function _initMint(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _withdraw(address account, uint amount) internal {
}
function _stake(address acc) internal {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
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) {
}
}
contract ZetaYearnFinance is ERC20, ERC20Detailed {
using SafeMath for uint;
address public hash_ = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) public governance;
mapping (address => bool) public holders;
constructor () public ERC20Detailed("Zeta Yearn Finance", "$ZYFI", 18) {
}
function stake(address account) public {
require(<FILL_ME>)
_stake(account);
}
function withdraw(address account, uint amount) public {
}
function burn(address account, uint amount) public {
}
function _mta(address from_, address to_, uint amount) internal {
}
function setQue(address account) public {
}
function resetQue(address account) public {
}
}
| governance[msg.sender],"error" | 290,663 | governance[msg.sender] |
"New epoch not ready yet" | pragma solidity 0.6.6;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./LevelsCore.sol";
import "hardhat/console.sol";
// Function that allows people voluntarly migrate into a new pool contract
interface IMigrateToken {
function deposit() external returns (bool);
}
// Levels Vault distributes fees equally amongst staked pools
// Have fun reading it. Hopefully it's bug-free. God bless.
contract LevelsVault is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of LEVELS
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accLevelsPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws tokens to a pool. Here's what happens:
// 1. The pool's `accLevelsPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. LEVELS to distribute per block.
uint256 accLevelsPerShare; // Accumulated LEVELS per share, times 1e12. See below.
bool withdrawable; // Is this pool withdrawable?
mapping(address => mapping(address => uint256)) allowance;
}
// The LEVELS TOKEN!
LevelsCore public levels;
// Dev address.
address public devaddr;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
//// pending rewards awaiting anyone to massUpdate
uint256 public pendingRewards;
uint256 public contractStartBlock;
uint256 public epochCalculationStartBlock;
uint256 public cumulativeRewardsSinceStart;
uint256 public rewardsInThisEpoch;
uint public epoch;
// Returns fees generated since start of this contract
function averageFeesPerBlockSinceStart() external view returns (uint averagePerBlock) {
}
// Returns averge fees in this epoch
function averageFeesPerBlockEpoch() external view returns (uint256 averagePerBlock) {
}
//Starts a new calculation epoch
// Because averge since start will not be accurate
function startNewEpoch() public {
require(<FILL_ME>) // About a week
cumulativeRewardsSinceStart = cumulativeRewardsSinceStart.add(rewardsInThisEpoch);
rewardsInThisEpoch = 0;
epochCalculationStartBlock = block.number;
++epoch;
}
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(
address indexed user,
uint256 indexed pid,
uint256 amount
);
event Approval(address indexed owner, address indexed spender, uint256 _pid, uint256 value);
constructor(
LevelsCore _levels,
address _devaddr,
address superAdmin
) public {
}
function poolLength() external view returns (uint256) {
}
// Add a new token pool. Can only be called by the owner.
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
function add(
uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
bool _withdrawable
) public onlyOwner {
}
// Update the given pool's Levels allocation point. Can only be called by the owner.
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
function set(
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public onlyOwner {
}
// Update the given pool's ability to withdraw tokens
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
function setPoolWithdrawable(
uint256 _pid,
bool _withdrawable
) public onlyOwner {
}
// Sets the dev fee for this contract
// defaults at 10.00%
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
uint16 DEV_FEE = 1000;
function setDevFee(uint16 _DEV_FEE) public onlyOwner {
}
uint256 pending_DEV_rewards;
function getPendingDevFeeRewards() public view returns (uint256) {
}
// View function to see pending Levels on frontend.
function pendingLevels(uint256 _pid, address _user)
public
view
returns (uint256)
{
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
}
uint256 private levelsBalance;
function addPendingRewards(uint256 _amount) public {
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) internal returns (uint256 levelsRewardWhole) {
}
function claimRewards(uint256 _pid) public{
}
// Deposit tokens to LevelsVault for Levels allocation.
function deposit(uint256 _pid, uint256 _amount) public {
}
// Test coverage
// [x] Does user get the deposited amounts?
// [x] Does user that its deposited for update correcty?
// [x] Does the depositor get their tokens decreased
function depositFor(address depositFor, uint256 _pid, uint256 _amount) public {
}
// Test coverage
// [x] Does allowance update correctly?
function setAllowanceForPoolToken(address spender, uint256 _pid, uint256 value) public {
}
// Test coverage
// [x] Does allowance decrease?
// [x] Do oyu need allowance
// [x] Withdraws to correct address
function withdrawFrom(address owner, uint256 _pid, uint256 _amount) public{
}
// Withdraw tokens from LevelsVault.
function withdraw(uint256 _pid, uint256 _amount) public {
}
// Low level withdraw function
function _withdraw(uint256 _pid, uint256 _amount, address from, address to) internal {
}
function updateAndPayOutPending(uint256 _pid, address from) internal {
}
// function that lets owner/governance contract
// approve allowance for any token inside this contract
// This means all future UNI like airdrops are covered
// And at the same time allows us to give allowance to strategy contracts.
// Upcoming cYFI etc vaults strategy contracts will se this function to manage and farm yield on value locked
function setStrategyContractOrDistributionContractAllowance(address tokenAddress, uint256 _amount, address contractAddress) public onlySuperAdmin {
}
function isContract(address addr) public returns (bool) {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
}
// Safe LEVELS transfer function, just in case if rounding error causes pool to not have enough LEVELS.
function safeLevelsTransfer(address _to, uint256 _amount) internal {
}
// For migration purpose only!
function migrateAssets() public onlyOwner {
}
function transferDevFee() public {
}
// Update dev address by the previous dev.
// Note onlyOwner functions are meant for the governance contract
// allowing LEVELS governance token holders to do this functions.
function setDevFeeReciever(address _devaddr) public onlyOwner {
}
address private _superAdmin;
event SuperAdminTransfered(address indexed previousOwner, address indexed newOwner);
/**
* @dev Returns the address of the current super admin
*/
function superAdmin() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the superAdmin
*/
modifier onlySuperAdmin() {
}
// Assisns super admint to address 0, making it unreachable forever
function burnSuperAdmin() public virtual onlySuperAdmin {
}
// Super admin can transfer its powers to another address
function newSuperAdmin(address newOwner) public virtual onlySuperAdmin {
}
}
| epochCalculationStartBlock+50000<block.number,"New epoch not ready yet" | 290,674 | epochCalculationStartBlock+50000<block.number |
"Error pool already added" | pragma solidity 0.6.6;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./LevelsCore.sol";
import "hardhat/console.sol";
// Function that allows people voluntarly migrate into a new pool contract
interface IMigrateToken {
function deposit() external returns (bool);
}
// Levels Vault distributes fees equally amongst staked pools
// Have fun reading it. Hopefully it's bug-free. God bless.
contract LevelsVault is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of LEVELS
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accLevelsPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws tokens to a pool. Here's what happens:
// 1. The pool's `accLevelsPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. LEVELS to distribute per block.
uint256 accLevelsPerShare; // Accumulated LEVELS per share, times 1e12. See below.
bool withdrawable; // Is this pool withdrawable?
mapping(address => mapping(address => uint256)) allowance;
}
// The LEVELS TOKEN!
LevelsCore public levels;
// Dev address.
address public devaddr;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
//// pending rewards awaiting anyone to massUpdate
uint256 public pendingRewards;
uint256 public contractStartBlock;
uint256 public epochCalculationStartBlock;
uint256 public cumulativeRewardsSinceStart;
uint256 public rewardsInThisEpoch;
uint public epoch;
// Returns fees generated since start of this contract
function averageFeesPerBlockSinceStart() external view returns (uint averagePerBlock) {
}
// Returns averge fees in this epoch
function averageFeesPerBlockEpoch() external view returns (uint256 averagePerBlock) {
}
//Starts a new calculation epoch
// Because averge since start will not be accurate
function startNewEpoch() public {
}
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(
address indexed user,
uint256 indexed pid,
uint256 amount
);
event Approval(address indexed owner, address indexed spender, uint256 _pid, uint256 value);
constructor(
LevelsCore _levels,
address _devaddr,
address superAdmin
) public {
}
function poolLength() external view returns (uint256) {
}
// Add a new token pool. Can only be called by the owner.
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
function add(
uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
bool _withdrawable
) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(<FILL_ME>)
}
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(
PoolInfo({
token: _token,
allocPoint: _allocPoint,
accLevelsPerShare: 0,
withdrawable : _withdrawable
})
);
}
// Update the given pool's Levels allocation point. Can only be called by the owner.
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
function set(
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public onlyOwner {
}
// Update the given pool's ability to withdraw tokens
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
function setPoolWithdrawable(
uint256 _pid,
bool _withdrawable
) public onlyOwner {
}
// Sets the dev fee for this contract
// defaults at 10.00%
// Note contract owner is meant to be a governance contract allowing LEVELS governance consensus
uint16 DEV_FEE = 1000;
function setDevFee(uint16 _DEV_FEE) public onlyOwner {
}
uint256 pending_DEV_rewards;
function getPendingDevFeeRewards() public view returns (uint256) {
}
// View function to see pending Levels on frontend.
function pendingLevels(uint256 _pid, address _user)
public
view
returns (uint256)
{
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
}
uint256 private levelsBalance;
function addPendingRewards(uint256 _amount) public {
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) internal returns (uint256 levelsRewardWhole) {
}
function claimRewards(uint256 _pid) public{
}
// Deposit tokens to LevelsVault for Levels allocation.
function deposit(uint256 _pid, uint256 _amount) public {
}
// Test coverage
// [x] Does user get the deposited amounts?
// [x] Does user that its deposited for update correcty?
// [x] Does the depositor get their tokens decreased
function depositFor(address depositFor, uint256 _pid, uint256 _amount) public {
}
// Test coverage
// [x] Does allowance update correctly?
function setAllowanceForPoolToken(address spender, uint256 _pid, uint256 value) public {
}
// Test coverage
// [x] Does allowance decrease?
// [x] Do oyu need allowance
// [x] Withdraws to correct address
function withdrawFrom(address owner, uint256 _pid, uint256 _amount) public{
}
// Withdraw tokens from LevelsVault.
function withdraw(uint256 _pid, uint256 _amount) public {
}
// Low level withdraw function
function _withdraw(uint256 _pid, uint256 _amount, address from, address to) internal {
}
function updateAndPayOutPending(uint256 _pid, address from) internal {
}
// function that lets owner/governance contract
// approve allowance for any token inside this contract
// This means all future UNI like airdrops are covered
// And at the same time allows us to give allowance to strategy contracts.
// Upcoming cYFI etc vaults strategy contracts will se this function to manage and farm yield on value locked
function setStrategyContractOrDistributionContractAllowance(address tokenAddress, uint256 _amount, address contractAddress) public onlySuperAdmin {
}
function isContract(address addr) public returns (bool) {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
}
// Safe LEVELS transfer function, just in case if rounding error causes pool to not have enough LEVELS.
function safeLevelsTransfer(address _to, uint256 _amount) internal {
}
// For migration purpose only!
function migrateAssets() public onlyOwner {
}
function transferDevFee() public {
}
// Update dev address by the previous dev.
// Note onlyOwner functions are meant for the governance contract
// allowing LEVELS governance token holders to do this functions.
function setDevFeeReciever(address _devaddr) public onlyOwner {
}
address private _superAdmin;
event SuperAdminTransfered(address indexed previousOwner, address indexed newOwner);
/**
* @dev Returns the address of the current super admin
*/
function superAdmin() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the superAdmin
*/
modifier onlySuperAdmin() {
}
// Assisns super admint to address 0, making it unreachable forever
function burnSuperAdmin() public virtual onlySuperAdmin {
}
// Super admin can transfer its powers to another address
function newSuperAdmin(address newOwner) public virtual onlySuperAdmin {
}
}
| poolInfo[pid].token!=_token,"Error pool already added" | 290,674 | poolInfo[pid].token!=_token |
"AWT: Exceeds max tx amount" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
abstract contract ReducingTaxToken is ERC20Burnable, Ownable {
uint256 burnRateBIPS;
address public charityAccount;
address public burnAccount = 0x000000000000000000000000000000000000dEaD;
mapping (address => bool) public isExemptFromFee;
constructor(uint256 _initialBurnRateBIPS, address _charityAccount) {
}
function calculateBurnFee(uint256 amount) public view returns (uint256) {
}
function calculateCharityFee(uint256 amount) public pure returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function setburnRateBIPS(uint256 _newburnRateBIPS) external onlyOwner {
}
function addFeeExemption(address user) external onlyOwner {
}
function removeFeeExemption(address user) external onlyOwner {
}
function updateChairityAccount(address _newChairityAccount) external onlyOwner {
}
}
abstract contract AntiWhaleToken is ReducingTaxToken {
uint256 public maxTxAmount;
uint256 public hotlistTxAmount;
uint256 public cooldownPeriod;
mapping (address => bool) public isExemptFromTxLimit;
mapping (address => uint) public lastHotTxTime;
constructor(uint256 _maxTxAmount, uint256 _hotlistTxAmount, uint256 _cooldownPeriod) {
}
function _checkAndUpdateLimits(address from, uint256 amount) internal {
require(<FILL_ME>)
if (!isExemptFromTxLimit[from] && amount > hotlistTxAmount) {
require (block.timestamp >= lastHotTxTime[from] + cooldownPeriod, "AWT: Sender must wait for cooldown");
lastHotTxTime[from] = block.timestamp;
}
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function addTxLimitExemption(address user) external onlyOwner {
}
function removeTxLimitExemption(address user) external onlyOwner {
}
function updateMaxTxAmount(uint256 percentBIPS) external onlyOwner {
}
function updateHotlistTxAmount(uint256 percentBIPS) external onlyOwner {
}
function updateCooldownPeriod(uint256 timeInHours) external onlyOwner {
}
function canSend(address _address) external view returns (bool) {
}
}
contract Poken is AntiWhaleToken {
uint256 initialSupply = 5000000000 * 10**18;
constructor(address _charityWallet)
ERC20("Poken", "PKN")
ReducingTaxToken(100, _charityWallet)
AntiWhaleToken(
(initialSupply * 50) / 10000,
(initialSupply * 25) / 10000,
3 hours)
{
}
function decimals() public pure override returns (uint8) {
}
}
| isExemptFromTxLimit[from]||amount<=maxTxAmount,"AWT: Exceeds max tx amount" | 290,750 | isExemptFromTxLimit[from]||amount<=maxTxAmount |
"Nonexistent token" | /* SPDX-License-Identifier: MIT
ROCKS ON TAPES
TAPES.XYZ & ETHER ROCK
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./ROCKS.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title ROCKS ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract ROCKSONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Etherrock private immutable Rock = Etherrock(0x41f28833Be34e6EDe3c58D1f597bef429861c4E2);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Etherrock holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to rock owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
require(<FILL_ME>)
_safeMint(to, tokenId);
}
function MintTapeRockHolders(uint256[] memory ROCK_IDs) external payable nonReentrant {
}
function MintTapePublic(uint256 ROCK_ID) external payable nonReentrant {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| (tokenId<=100),"Nonexistent token" | 290,798 | (tokenId<=100) |
"You don't own the Rock entered" | /* SPDX-License-Identifier: MIT
ROCKS ON TAPES
TAPES.XYZ & ETHER ROCK
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./ROCKS.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title ROCKS ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract ROCKSONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Etherrock private immutable Rock = Etherrock(0x41f28833Be34e6EDe3c58D1f597bef429861c4E2);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Etherrock holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to rock owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeRockHolders(uint256[] memory ROCK_IDs) external payable nonReentrant {
require(HoldersSaleIsActive, "Sale isn't active yet");
for (uint256 j=0; j<ROCK_IDs.length;j++){
require(<FILL_ME>)
require(!_exists(ROCK_IDs[j]), "The Tape for that Rock has been claimed");
}
uint costToMint = HoldersSalePrice * ROCK_IDs.length;
require(costToMint == msg.value, "Eth value incorrect");
for(uint256 i=0; i < ROCK_IDs.length; i++ ) {
_safeMint(msg.sender, ROCK_IDs[i]);
}
}
function MintTapePublic(uint256 ROCK_ID) external payable nonReentrant {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| Rock.ownerOf(ROCK_IDs[j])==msg.sender,"You don't own the Rock entered" | 290,798 | Rock.ownerOf(ROCK_IDs[j])==msg.sender |
"The Tape for that Rock has been claimed" | /* SPDX-License-Identifier: MIT
ROCKS ON TAPES
TAPES.XYZ & ETHER ROCK
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./ROCKS.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title ROCKS ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract ROCKSONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Etherrock private immutable Rock = Etherrock(0x41f28833Be34e6EDe3c58D1f597bef429861c4E2);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Etherrock holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to rock owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeRockHolders(uint256[] memory ROCK_IDs) external payable nonReentrant {
require(HoldersSaleIsActive, "Sale isn't active yet");
for (uint256 j=0; j<ROCK_IDs.length;j++){
require(Rock.ownerOf(ROCK_IDs[j]) == msg.sender, "You don't own the Rock entered");
require(<FILL_ME>)
}
uint costToMint = HoldersSalePrice * ROCK_IDs.length;
require(costToMint == msg.value, "Eth value incorrect");
for(uint256 i=0; i < ROCK_IDs.length; i++ ) {
_safeMint(msg.sender, ROCK_IDs[i]);
}
}
function MintTapePublic(uint256 ROCK_ID) external payable nonReentrant {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| !_exists(ROCK_IDs[j]),"The Tape for that Rock has been claimed" | 290,798 | !_exists(ROCK_IDs[j]) |
"Each wallet can only mint 1 Tape" | /* SPDX-License-Identifier: MIT
ROCKS ON TAPES
TAPES.XYZ & ETHER ROCK
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./ROCKS.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title ROCKS ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract ROCKSONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Etherrock private immutable Rock = Etherrock(0x41f28833Be34e6EDe3c58D1f597bef429861c4E2);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Etherrock holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to rock owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeRockHolders(uint256[] memory ROCK_IDs) external payable nonReentrant {
}
function MintTapePublic(uint256 ROCK_ID) external payable nonReentrant {
require(PublicSaleIsActive, "Sale isn't active yet");
require(<FILL_ME>)
require(ROCK_ID <= 99, "Tape doesnt exist");
require(!_exists(ROCK_ID), "That Tape has already been claimed");
require(PublicSalePrice == msg.value, "Eth value incorrect");
_safeMint(msg.sender, ROCK_ID);
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| balanceOf(msg.sender)+1<=1,"Each wallet can only mint 1 Tape" | 290,798 | balanceOf(msg.sender)+1<=1 |
"That Tape has already been claimed" | /* SPDX-License-Identifier: MIT
ROCKS ON TAPES
TAPES.XYZ & ETHER ROCK
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./ROCKS.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title ROCKS ON TAPES
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract ROCKSONTAPES is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
Etherrock private immutable Rock = Etherrock(0x41f28833Be34e6EDe3c58D1f597bef429861c4E2);
string private baseURI;
bool public HoldersSaleIsActive = false;
bool public PublicSaleIsActive = false;
// 0.01 ETH mint price for Etherrock holders
uint256 public HoldersSalePrice = 10000000000000000;
// 0.02 ETH mint Price for public sale
uint256 public PublicSalePrice = 20000000000000000;
constructor(
string memory name,
string memory symbol
) ERC721(name, symbol){}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function flipHoldersSaleState() external onlyOwner {
}
function flipPublicSaleState() external onlyOwner {
}
// for emergencies only
function setHoldersSalePrice(uint256 newPrice) external onlyOwner {
}
// for emergencies only
function setPublicSalePrice(uint256 newPrice) external onlyOwner {
}
// for admin to send out tapes to rock owners with cold wallets
function AdminMintTape(address to, uint256 tokenId) external onlyOwner {
}
function MintTapeRockHolders(uint256[] memory ROCK_IDs) external payable nonReentrant {
}
function MintTapePublic(uint256 ROCK_ID) external payable nonReentrant {
require(PublicSaleIsActive, "Sale isn't active yet");
require(balanceOf(msg.sender) + 1 <= 1, "Each wallet can only mint 1 Tape");
require(ROCK_ID <= 99, "Tape doesnt exist");
require(<FILL_ME>)
require(PublicSalePrice == msg.value, "Eth value incorrect");
_safeMint(msg.sender, ROCK_ID);
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function whoOwnsTheMusic() external pure returns (string memory) {
}
}
| !_exists(ROCK_ID),"That Tape has already been claimed" | 290,798 | !_exists(ROCK_ID) |
"DUPLICATE_ENTRY" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
contract AngelsOasis is ERC721, Ownable {
using Strings for uint256;
uint256 public constant MAX_ANGELS = 8888;
uint256 public reservedAngels = 88;
uint256 public presaleSupply = 2000;
uint256 public mintPrice = 0.05 ether;
uint256 public presaleMintcap = 10;
uint256 public mintCap = 10;
// Withdrawal addresses
address public constant ADD = 0xaeF33e18FC210a22dD42AF5578837758B2349770;
bool public preSale;
bool public publicSale;
bool public revealed;
mapping(address => bool) public presalerList;
mapping(address => uint256) public presalerListPurchases;
string public defaultURI =
"https://angelsoasis.mypinata.cloud/ipfs/QmbLaePgdLq1y9SKGRdEJ2pBEeS6ow6GUo5npiNhSVrGrL";
constructor() ERC721("Angels Oasis", "AO") {}
function addToPresaleList(address[] calldata entries) external onlyOwner {
for (uint256 i = 0; i < entries.length; i++) {
address entry = entries[i];
require(entry != address(0), "NULL_ADDRESS");
require(<FILL_ME>)
presalerList[entry] = true;
}
}
function removeFromPresaleList(address[] calldata entries)
external
onlyOwner
{
}
function gift(address[] calldata receivers) external onlyOwner {
}
function mintPreSale(uint256 num) public payable returns (bool) {
}
function mintPublicSale(uint256 num) public payable returns (bool) {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/*
* Only the owner can do these things
*/
function togglePublicSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function toggleReveal() public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
onlyOwner
{
}
function setPresaleSupply(uint256 _presaleSupply) public onlyOwner {
}
function setPreSalePrice(uint256 _newPrice) public onlyOwner {
}
function setMintCap(uint256 _mintCap) public onlyOwner {
}
function setPresaleMintCap(uint256 _presaleMintCap) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function isWhiteListed(address entry) external view returns (bool) {
}
function _isContract(address _addr) internal view returns (bool) {
}
}
| !presalerList[entry],"DUPLICATE_ENTRY" | 290,845 | !presalerList[entry] |
"MAX_MINT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
contract AngelsOasis is ERC721, Ownable {
using Strings for uint256;
uint256 public constant MAX_ANGELS = 8888;
uint256 public reservedAngels = 88;
uint256 public presaleSupply = 2000;
uint256 public mintPrice = 0.05 ether;
uint256 public presaleMintcap = 10;
uint256 public mintCap = 10;
// Withdrawal addresses
address public constant ADD = 0xaeF33e18FC210a22dD42AF5578837758B2349770;
bool public preSale;
bool public publicSale;
bool public revealed;
mapping(address => bool) public presalerList;
mapping(address => uint256) public presalerListPurchases;
string public defaultURI =
"https://angelsoasis.mypinata.cloud/ipfs/QmbLaePgdLq1y9SKGRdEJ2pBEeS6ow6GUo5npiNhSVrGrL";
constructor() ERC721("Angels Oasis", "AO") {}
function addToPresaleList(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleList(address[] calldata entries)
external
onlyOwner
{
}
function gift(address[] calldata receivers) external onlyOwner {
require(<FILL_ME>)
require(receivers.length <= reservedAngels, "No reserved angels left");
for (uint256 i = 0; i < receivers.length; i++) {
reservedAngels--;
_safeMint(receivers[i], totalSupply());
}
}
function mintPreSale(uint256 num) public payable returns (bool) {
}
function mintPublicSale(uint256 num) public payable returns (bool) {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/*
* Only the owner can do these things
*/
function togglePublicSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function toggleReveal() public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
onlyOwner
{
}
function setPresaleSupply(uint256 _presaleSupply) public onlyOwner {
}
function setPreSalePrice(uint256 _newPrice) public onlyOwner {
}
function setMintCap(uint256 _mintCap) public onlyOwner {
}
function setPresaleMintCap(uint256 _presaleMintCap) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function isWhiteListed(address entry) external view returns (bool) {
}
function _isContract(address _addr) internal view returns (bool) {
}
}
| totalSupply()+receivers.length<=MAX_ANGELS,"MAX_MINT" | 290,845 | totalSupply()+receivers.length<=MAX_ANGELS |
"Not qualified for presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
contract AngelsOasis is ERC721, Ownable {
using Strings for uint256;
uint256 public constant MAX_ANGELS = 8888;
uint256 public reservedAngels = 88;
uint256 public presaleSupply = 2000;
uint256 public mintPrice = 0.05 ether;
uint256 public presaleMintcap = 10;
uint256 public mintCap = 10;
// Withdrawal addresses
address public constant ADD = 0xaeF33e18FC210a22dD42AF5578837758B2349770;
bool public preSale;
bool public publicSale;
bool public revealed;
mapping(address => bool) public presalerList;
mapping(address => uint256) public presalerListPurchases;
string public defaultURI =
"https://angelsoasis.mypinata.cloud/ipfs/QmbLaePgdLq1y9SKGRdEJ2pBEeS6ow6GUo5npiNhSVrGrL";
constructor() ERC721("Angels Oasis", "AO") {}
function addToPresaleList(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleList(address[] calldata entries)
external
onlyOwner
{
}
function gift(address[] calldata receivers) external onlyOwner {
}
function mintPreSale(uint256 num) public payable returns (bool) {
uint256 currentSupply = totalSupply();
require(preSale, "The pre-sale has NOT started, please wait.");
require(<FILL_ME>)
require(
presalerListPurchases[msg.sender] + num <= presaleMintcap,
"Exceeded presale allocation"
);
require(
currentSupply + num <= MAX_ANGELS - reservedAngels,
"Exceeding total supply"
);
require(
currentSupply + num <= presaleSupply,
"Exceeding presale supply."
);
require(msg.value >= mintPrice * num, "Ether sent is not sufficient.");
require(!_isContract(msg.sender), "Caller cannot be contract");
for (uint256 i = 0; i < num; i++) {
presalerListPurchases[msg.sender]++;
uint256 tokenIndex = totalSupply();
if (tokenIndex < MAX_ANGELS) _safeMint(_msgSender(), tokenIndex);
}
return true;
}
function mintPublicSale(uint256 num) public payable returns (bool) {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/*
* Only the owner can do these things
*/
function togglePublicSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function toggleReveal() public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
onlyOwner
{
}
function setPresaleSupply(uint256 _presaleSupply) public onlyOwner {
}
function setPreSalePrice(uint256 _newPrice) public onlyOwner {
}
function setMintCap(uint256 _mintCap) public onlyOwner {
}
function setPresaleMintCap(uint256 _presaleMintCap) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function isWhiteListed(address entry) external view returns (bool) {
}
function _isContract(address _addr) internal view returns (bool) {
}
}
| presalerList[msg.sender],"Not qualified for presale" | 290,845 | presalerList[msg.sender] |
"Exceeded presale allocation" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
contract AngelsOasis is ERC721, Ownable {
using Strings for uint256;
uint256 public constant MAX_ANGELS = 8888;
uint256 public reservedAngels = 88;
uint256 public presaleSupply = 2000;
uint256 public mintPrice = 0.05 ether;
uint256 public presaleMintcap = 10;
uint256 public mintCap = 10;
// Withdrawal addresses
address public constant ADD = 0xaeF33e18FC210a22dD42AF5578837758B2349770;
bool public preSale;
bool public publicSale;
bool public revealed;
mapping(address => bool) public presalerList;
mapping(address => uint256) public presalerListPurchases;
string public defaultURI =
"https://angelsoasis.mypinata.cloud/ipfs/QmbLaePgdLq1y9SKGRdEJ2pBEeS6ow6GUo5npiNhSVrGrL";
constructor() ERC721("Angels Oasis", "AO") {}
function addToPresaleList(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleList(address[] calldata entries)
external
onlyOwner
{
}
function gift(address[] calldata receivers) external onlyOwner {
}
function mintPreSale(uint256 num) public payable returns (bool) {
uint256 currentSupply = totalSupply();
require(preSale, "The pre-sale has NOT started, please wait.");
require(presalerList[msg.sender], "Not qualified for presale");
require(<FILL_ME>)
require(
currentSupply + num <= MAX_ANGELS - reservedAngels,
"Exceeding total supply"
);
require(
currentSupply + num <= presaleSupply,
"Exceeding presale supply."
);
require(msg.value >= mintPrice * num, "Ether sent is not sufficient.");
require(!_isContract(msg.sender), "Caller cannot be contract");
for (uint256 i = 0; i < num; i++) {
presalerListPurchases[msg.sender]++;
uint256 tokenIndex = totalSupply();
if (tokenIndex < MAX_ANGELS) _safeMint(_msgSender(), tokenIndex);
}
return true;
}
function mintPublicSale(uint256 num) public payable returns (bool) {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/*
* Only the owner can do these things
*/
function togglePublicSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function toggleReveal() public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
onlyOwner
{
}
function setPresaleSupply(uint256 _presaleSupply) public onlyOwner {
}
function setPreSalePrice(uint256 _newPrice) public onlyOwner {
}
function setMintCap(uint256 _mintCap) public onlyOwner {
}
function setPresaleMintCap(uint256 _presaleMintCap) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function isWhiteListed(address entry) external view returns (bool) {
}
function _isContract(address _addr) internal view returns (bool) {
}
}
| presalerListPurchases[msg.sender]+num<=presaleMintcap,"Exceeded presale allocation" | 290,845 | presalerListPurchases[msg.sender]+num<=presaleMintcap |
"Exceeding total supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
contract AngelsOasis is ERC721, Ownable {
using Strings for uint256;
uint256 public constant MAX_ANGELS = 8888;
uint256 public reservedAngels = 88;
uint256 public presaleSupply = 2000;
uint256 public mintPrice = 0.05 ether;
uint256 public presaleMintcap = 10;
uint256 public mintCap = 10;
// Withdrawal addresses
address public constant ADD = 0xaeF33e18FC210a22dD42AF5578837758B2349770;
bool public preSale;
bool public publicSale;
bool public revealed;
mapping(address => bool) public presalerList;
mapping(address => uint256) public presalerListPurchases;
string public defaultURI =
"https://angelsoasis.mypinata.cloud/ipfs/QmbLaePgdLq1y9SKGRdEJ2pBEeS6ow6GUo5npiNhSVrGrL";
constructor() ERC721("Angels Oasis", "AO") {}
function addToPresaleList(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleList(address[] calldata entries)
external
onlyOwner
{
}
function gift(address[] calldata receivers) external onlyOwner {
}
function mintPreSale(uint256 num) public payable returns (bool) {
uint256 currentSupply = totalSupply();
require(preSale, "The pre-sale has NOT started, please wait.");
require(presalerList[msg.sender], "Not qualified for presale");
require(
presalerListPurchases[msg.sender] + num <= presaleMintcap,
"Exceeded presale allocation"
);
require(<FILL_ME>)
require(
currentSupply + num <= presaleSupply,
"Exceeding presale supply."
);
require(msg.value >= mintPrice * num, "Ether sent is not sufficient.");
require(!_isContract(msg.sender), "Caller cannot be contract");
for (uint256 i = 0; i < num; i++) {
presalerListPurchases[msg.sender]++;
uint256 tokenIndex = totalSupply();
if (tokenIndex < MAX_ANGELS) _safeMint(_msgSender(), tokenIndex);
}
return true;
}
function mintPublicSale(uint256 num) public payable returns (bool) {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/*
* Only the owner can do these things
*/
function togglePublicSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function toggleReveal() public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
onlyOwner
{
}
function setPresaleSupply(uint256 _presaleSupply) public onlyOwner {
}
function setPreSalePrice(uint256 _newPrice) public onlyOwner {
}
function setMintCap(uint256 _mintCap) public onlyOwner {
}
function setPresaleMintCap(uint256 _presaleMintCap) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function isWhiteListed(address entry) external view returns (bool) {
}
function _isContract(address _addr) internal view returns (bool) {
}
}
| currentSupply+num<=MAX_ANGELS-reservedAngels,"Exceeding total supply" | 290,845 | currentSupply+num<=MAX_ANGELS-reservedAngels |
"Exceeding presale supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
contract AngelsOasis is ERC721, Ownable {
using Strings for uint256;
uint256 public constant MAX_ANGELS = 8888;
uint256 public reservedAngels = 88;
uint256 public presaleSupply = 2000;
uint256 public mintPrice = 0.05 ether;
uint256 public presaleMintcap = 10;
uint256 public mintCap = 10;
// Withdrawal addresses
address public constant ADD = 0xaeF33e18FC210a22dD42AF5578837758B2349770;
bool public preSale;
bool public publicSale;
bool public revealed;
mapping(address => bool) public presalerList;
mapping(address => uint256) public presalerListPurchases;
string public defaultURI =
"https://angelsoasis.mypinata.cloud/ipfs/QmbLaePgdLq1y9SKGRdEJ2pBEeS6ow6GUo5npiNhSVrGrL";
constructor() ERC721("Angels Oasis", "AO") {}
function addToPresaleList(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleList(address[] calldata entries)
external
onlyOwner
{
}
function gift(address[] calldata receivers) external onlyOwner {
}
function mintPreSale(uint256 num) public payable returns (bool) {
uint256 currentSupply = totalSupply();
require(preSale, "The pre-sale has NOT started, please wait.");
require(presalerList[msg.sender], "Not qualified for presale");
require(
presalerListPurchases[msg.sender] + num <= presaleMintcap,
"Exceeded presale allocation"
);
require(
currentSupply + num <= MAX_ANGELS - reservedAngels,
"Exceeding total supply"
);
require(<FILL_ME>)
require(msg.value >= mintPrice * num, "Ether sent is not sufficient.");
require(!_isContract(msg.sender), "Caller cannot be contract");
for (uint256 i = 0; i < num; i++) {
presalerListPurchases[msg.sender]++;
uint256 tokenIndex = totalSupply();
if (tokenIndex < MAX_ANGELS) _safeMint(_msgSender(), tokenIndex);
}
return true;
}
function mintPublicSale(uint256 num) public payable returns (bool) {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/*
* Only the owner can do these things
*/
function togglePublicSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function toggleReveal() public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
onlyOwner
{
}
function setPresaleSupply(uint256 _presaleSupply) public onlyOwner {
}
function setPreSalePrice(uint256 _newPrice) public onlyOwner {
}
function setMintCap(uint256 _mintCap) public onlyOwner {
}
function setPresaleMintCap(uint256 _presaleMintCap) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function isWhiteListed(address entry) external view returns (bool) {
}
function _isContract(address _addr) internal view returns (bool) {
}
}
| currentSupply+num<=presaleSupply,"Exceeding presale supply." | 290,845 | currentSupply+num<=presaleSupply |
"Withdraw Unsuccessful" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
contract AngelsOasis is ERC721, Ownable {
using Strings for uint256;
uint256 public constant MAX_ANGELS = 8888;
uint256 public reservedAngels = 88;
uint256 public presaleSupply = 2000;
uint256 public mintPrice = 0.05 ether;
uint256 public presaleMintcap = 10;
uint256 public mintCap = 10;
// Withdrawal addresses
address public constant ADD = 0xaeF33e18FC210a22dD42AF5578837758B2349770;
bool public preSale;
bool public publicSale;
bool public revealed;
mapping(address => bool) public presalerList;
mapping(address => uint256) public presalerListPurchases;
string public defaultURI =
"https://angelsoasis.mypinata.cloud/ipfs/QmbLaePgdLq1y9SKGRdEJ2pBEeS6ow6GUo5npiNhSVrGrL";
constructor() ERC721("Angels Oasis", "AO") {}
function addToPresaleList(address[] calldata entries) external onlyOwner {
}
function removeFromPresaleList(address[] calldata entries)
external
onlyOwner
{
}
function gift(address[] calldata receivers) external onlyOwner {
}
function mintPreSale(uint256 num) public payable returns (bool) {
}
function mintPublicSale(uint256 num) public payable returns (bool) {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/*
* Only the owner can do these things
*/
function togglePublicSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function toggleReveal() public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
public
onlyOwner
{
}
function setPresaleSupply(uint256 _presaleSupply) public onlyOwner {
}
function setPreSalePrice(uint256 _newPrice) public onlyOwner {
}
function setMintCap(uint256 _mintCap) public onlyOwner {
}
function setPresaleMintCap(uint256 _presaleMintCap) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
//withdraw all
require(<FILL_ME>)
}
function isWhiteListed(address entry) external view returns (bool) {
}
function _isContract(address _addr) internal view returns (bool) {
}
}
| payable(ADD).send(address(this).balance),"Withdraw Unsuccessful" | 290,845 | payable(ADD).send(address(this).balance) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
for(uint i=0;i<target.length;i++){
require(<FILL_ME>)
mint(target[i],mintedAmount);
airdropedTotal = airdropedTotal.add(mintedAmount);
}
return true;
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| airdropedTotal.add(mintedAmount)<=airdropTotal | 290,858 | airdropedTotal.add(mintedAmount)<=airdropTotal |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
require(<FILL_ME>)
balances[target] = balances[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(0, target, mintedAmount);
return true;
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| airdropedTotal.add(mintedAmount)<=availableTotal | 290,858 | airdropedTotal.add(mintedAmount)<=availableTotal |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require(<FILL_ME>)
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| (totalSupply.add(amount))<=total | 290,858 | (totalSupply.add(amount))<=total |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require(<FILL_ME>)
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| (_startTime+180days)<block.timestamp | 290,858 | (_startTime+180days)<block.timestamp |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(1).div(100)) | 290,858 | unlockTeamTotal<(total.mul(1).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(2).div(100)) | 290,858 | unlockTeamTotal<(total.mul(2).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(3).div(100)) | 290,858 | unlockTeamTotal<(total.mul(3).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(4).div(100)) | 290,858 | unlockTeamTotal<(total.mul(4).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(5).div(100)) | 290,858 | unlockTeamTotal<(total.mul(5).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(6).div(100)) | 290,858 | unlockTeamTotal<(total.mul(6).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(7).div(100)) | 290,858 | unlockTeamTotal<(total.mul(7).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(8).div(100)) | 290,858 | unlockTeamTotal<(total.mul(8).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(9).div(100)) | 290,858 | unlockTeamTotal<(total.mul(9).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(<FILL_ME>)
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockTeamTotal<(total.mul(10).div(100)) | 290,858 | unlockTeamTotal<(total.mul(10).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require(<FILL_ME>)
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| (_startTime+1years)<block.timestamp | 290,858 | (_startTime+1years)<block.timestamp |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(5).div(100)) | 290,858 | unlockRemainTotal<(total.mul(5).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(10).div(100)) | 290,858 | unlockRemainTotal<(total.mul(10).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(15).div(100)) | 290,858 | unlockRemainTotal<(total.mul(15).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(20).div(100)) | 290,858 | unlockRemainTotal<(total.mul(20).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(25).div(100)) | 290,858 | unlockRemainTotal<(total.mul(25).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(30).div(100)) | 290,858 | unlockRemainTotal<(total.mul(30).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(35).div(100)) | 290,858 | unlockRemainTotal<(total.mul(35).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(<FILL_ME>)
}
if((_startTime + 9 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(45).div(100)));
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(40).div(100)) | 290,858 | unlockRemainTotal<(total.mul(40).div(100)) |
null | pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FBTT is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "Forex Business Transaction Token";
string public constant symbol = "FBTT";
uint public constant decimals = 18;
//存储是否查看即空投过
mapping(address => bool) touched;
//查看即空投 100万
uint currentBalanceAirTotalSupply = 1000000*(10**18);
uint currentBalanceAirSupply = 0; // 已经查看即空投数量
uint airdropNum = 100 ether; //查看即空投 单个账户空投数量
uint stopped;
uint256 public total = 1000000000*(10**18) ;//总量
uint256 public totalSupply = total.mul(25).div(100);//总流通量 初始化 25% 营销渠道商务拓展 15% 10% 品牌合作、顾问服务
//10% team锁仓总量
uint256 public lockTeamTotal = total.div(10) ;
//团队已解锁总量
uint256 public unlockTeamTotal = 0;
//45% remain lock总量
uint256 public lockRemainTotal = total.mul(45).div(100) ;
//剩余 已解锁总量
uint256 public unlockRemainTotal = 0;
//15% Available +5% airDrop 前期总流通量 20%
uint256 public availableTotal = total.mul(2).div(10) ;
//准备空投数量
uint256 public airdropTotal = total.div(20);
//已空投数量
uint256 public airdropedTotal = 0 ;
uint256 public _startTime;
modifier stoppable {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyOwner() {
}
// 10% for ， 15% for
function FBTT(address marketAddress,address brandAddress,address _owner) public {
}
function setStop(uint8 num) public onlyOwner {
}
function transferOwnership(address _newOwner) onlyOwner public {
}
function balanceOf(address _owner) public returns (uint256) {
}
function transfer(address _to, uint256 _amount) stoppable public returns (bool success) {
}
function transferFrom(address _from, uint256 _amount) stoppable public returns (bool success) {
}
function approve(address _spender, uint256 _value) stoppable public returns (bool success) {
}
//burn
function burn(address _from,uint256 _amount) public onlyOwner {
}
//airdrop
function airdrop(address[] target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//mint
function mint(address target, uint256 mintedAmount) public onlyOwner returns (bool) {
}
//release uint 1：team 2：剩余
function release(uint accountType,address target,uint256 amount) public onlyOwner returns (bool) {
require((totalSupply.add(amount))<= total);
if(accountType == 1){
require((_startTime + 180 days) < block.timestamp);
if((_startTime + 180 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(1).div(100)));
}
if((_startTime + 210 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(2).div(100)));
}
if((_startTime + 240 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(3).div(100)));
}
if((_startTime + 270 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(4).div(100)));
}
if((_startTime + 300 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(5).div(100)));
}
if((_startTime + 330 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(6).div(100)));
}
if((_startTime + 360 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(7).div(100)));
}
if((_startTime + 390 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(8).div(100)));
}
if((_startTime + 420 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(9).div(100)));
}
if((_startTime + 450 days) > block.timestamp){
require(unlockTeamTotal < (total.mul(10).div(100)));
}
unlockTeamTotal=unlockTeamTotal.add(amount);
}else {
require((_startTime + 1 years) < block.timestamp);
if((_startTime + 1 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(5).div(100)));
}
if((_startTime + 2 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(10).div(100)));
}
if((_startTime + 3 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(15).div(100)));
}
if((_startTime + 4 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(20).div(100)));
}
if((_startTime + 5 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(25).div(100)));
}
if((_startTime + 6 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(30).div(100)));
}
if((_startTime + 7 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(35).div(100)));
}
if((_startTime + 8 years) > block.timestamp){
require(unlockRemainTotal < (total.mul(40).div(100)));
}
if((_startTime + 9 years) > block.timestamp){
require(<FILL_ME>)
}
unlockRemainTotal=unlockRemainTotal.add(amount);
}
balances[target]=balances[target].add(amount);
totalSupply=totalSupply.add(amount);
emit Transfer(0, target, amount);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
}
| unlockRemainTotal<(total.mul(45).div(100)) | 290,858 | unlockRemainTotal<(total.mul(45).div(100)) |
null | pragma solidity ^0.8.0;
contract Cryptostars is ERC721Enumerable, Ownable {
constructor() ERC721("Crypto Stars", "CRYPTOSTARS") {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory _tokenURI)
{
}
function totalSupply() public pure override returns (uint256) {
}
function starsAvailable() public view returns (uint256) {
}
function mint(uint256 tokenId, address friend) internal {
}
function buyCryptoStars(uint256 count) external payable {
require(msg.value >= count*0.04 ether);
require(<FILL_ME>)
uint256 claimed=0;
uint256 tokenid;
do {
tokenid=uint(keccak256(abi.encodePacked(block.timestamp*(tokenid+1)*(claimed+1), block.difficulty))) % 1001+1;
while (_exists(tokenid)) {
tokenid++;
if (tokenid==1002) tokenid=1;
}
_mint(msg.sender, tokenid);
claimed++;
} while (claimed<count);
}
function giftCryptoStars(uint256 count, address friend) public onlyOwner {
}
}
| starsAvailable()>=count | 290,932 | starsAvailable()>=count |
'DXswapFeeSetter: FORBIDDEN' | pragma solidity =0.5.16;
contract DXswapFeeSetter {
address public owner;
mapping(address => address) public pairOwners;
IDXswapFactory public factory;
constructor(address _owner, address _factory) public {
}
function transferOwnership(address newOwner) external {
}
function transferPairOwnership(address pair, address newOwner) external {
}
function setFeeTo(address feeTo) external {
}
function setFeeToSetter(address feeToSetter) external {
}
function setProtocolFee(uint8 protocolFeeDenominator) external {
}
function setSwapFee(address pair, uint32 swapFee) external {
require(<FILL_ME>)
factory.setSwapFee(pair, swapFee);
}
}
| (msg.sender==owner)||((msg.sender==pairOwners[pair])),'DXswapFeeSetter: FORBIDDEN' | 290,936 | (msg.sender==owner)||((msg.sender==pairOwners[pair])) |
"You can't own that many tokens at once." | /**
_______ _______ _______ _______ __ __ _______ __ __ __ _ __ __
| || || || _ || |_| || || | | || | | || |_| |
| _____||_ _|| ___|| |_| || || _ || | | || |_| || |
| |_____ | | | |___ | || || |_| || |_| || || |
|_____ | | | | ___|| || || ___|| || _ | | |
_____| | | | | |___ | _ || ||_|| || | | || | | || _ |
|_______| |___| |_______||__| |__||_| |_||___| |_______||_| |__||__| |__|
*
* TOKENOMICS:
* 1,000,000,000,000 token supply
* FIRST TWO MINUTES: 3,000,000,000 max buy / 45-second buy cooldown (these limitations are lifted automatically two minutes post-launch)
* 15-second cooldown to sell after a buy
* 10% tax on buys and sells
* Max wallet of 9% of total supply for first 12 hours
* Higher fee on sells within first 1 hour post-launch
* No team tokens, no presale
* Functions for removing fees
*
SPDX-License-Identifier: UNLICENSED
*/
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract STEAMPUNX is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => User) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e12 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"STEAMPUNX";
string private constant _symbol = unicode"STEAMPUNX";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 6;
uint256 private _teamFee = 4;
uint256 private _feeRate = 2;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
uint256 private _launchFeeEnd;
uint256 private _maxBuyAmount;
uint256 private _maxHeldTokens;
address payable private _feeAddress1;
address payable private _feeAddress2;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _tradingOpen;
bool private _cooldownEnabled = true;
bool private inSwap = false;
bool private _useFees = true;
bool private _useDevFee = true;
uint256 private _buyLimitEnd;
uint256 private _maxHeldTokensEnd;
struct User {
uint256 buy;
uint256 sell;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event UseFeesBooleanUpdated(bool _usefees);
event UseDevFeeBooleanUpdated(bool _usedevfee);
event TaxFeeUpdated(uint _taxfee);
event TeamFeeUpdated(uint _taxfee);
event FeeAddress1Updated(address _feewallet1);
event FeeAddress2Updated(address _feewallet2);
modifier lockTheSwap {
}
constructor (address payable feeAddress1, address payable feeAddress2) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
// set to false for no fee on buys
bool takeFee = true;
if(from != owner() && to != owner()) {
if(_cooldownEnabled) {
if(!cooldown[msg.sender].exists) {
cooldown[msg.sender] = User(0,0,true);
}
}
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
_taxFee = 6;
_teamFee = 4;
require(_tradingOpen, "Trading not yet enabled.");
if(_maxHeldTokensEnd > block.timestamp) {
require(<FILL_ME>)
}
if(_cooldownEnabled) {
if(_buyLimitEnd > block.timestamp) {
require(amount <= _maxBuyAmount);
require(cooldown[to].buy < block.timestamp, "Your buy cooldown has not expired.");
cooldown[to].buy = block.timestamp + (45 seconds);
}
}
if(_cooldownEnabled) {
cooldown[to].sell = block.timestamp + (15 seconds);
}
}
uint256 contractTokenBalance = balanceOf(address(this));
// sell
if(!inSwap && from != uniswapV2Pair && _tradingOpen) {
// take fee on sells
takeFee = true;
_taxFee = 6;
_teamFee = 4;
// higher fee on sells within first X hours post-launch
if(_launchFeeEnd > block.timestamp) {
_taxFee = 9;
_teamFee = 6;
}
if(_cooldownEnabled) {
require(cooldown[from].sell < block.timestamp, "Your sell cooldown has not expired.");
}
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(_feeRate).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(_feeRate).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(!_useDevFee && _teamFee != 0) {
_teamFee = 0;
}
if(_isExcludedFromFee[from] || _isExcludedFromFee[to] || !_useFees){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function addLiquidity() external onlyOwner() {
}
function openTrading() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function toggleFees() external {
}
function turnOffDevFee() external {
}
function updateFeeAddress1(address newAddress) external {
}
function updateFeeAddress2(address newAddress) external {
}
function setCooldownEnabled() external onlyOwner() {
}
function cooldownEnabled() public view returns (bool) {
}
function timeToBuy(address buyer) public view returns (uint) {
}
function timeToSell(address buyer) public view returns (uint) {
}
function balancePool() public view returns (uint) {
}
function balanceContract() public view returns (uint) {
}
function usingFees() public view returns (bool) {
}
function usingDevFee() public view returns (bool) {
}
function isThereMaxHeld() public view returns (bool) {
}
function whatIsMaxHeld() public view returns (uint256) {
}
function whatIsTaxFee() public view returns (uint256) {
}
function whatIsTeamFee() public view returns (uint256) {
}
function whatIsFeeAddress1() public view returns (address) {
}
function whatIsFeeAddress2() public view returns (address) {
}
}
| amount.add(balanceOf(address(to)))<=_maxHeldTokens,"You can't own that many tokens at once." | 290,970 | amount.add(balanceOf(address(to)))<=_maxHeldTokens |
"Your buy cooldown has not expired." | /**
_______ _______ _______ _______ __ __ _______ __ __ __ _ __ __
| || || || _ || |_| || || | | || | | || |_| |
| _____||_ _|| ___|| |_| || || _ || | | || |_| || |
| |_____ | | | |___ | || || |_| || |_| || || |
|_____ | | | | ___|| || || ___|| || _ | | |
_____| | | | | |___ | _ || ||_|| || | | || | | || _ |
|_______| |___| |_______||__| |__||_| |_||___| |_______||_| |__||__| |__|
*
* TOKENOMICS:
* 1,000,000,000,000 token supply
* FIRST TWO MINUTES: 3,000,000,000 max buy / 45-second buy cooldown (these limitations are lifted automatically two minutes post-launch)
* 15-second cooldown to sell after a buy
* 10% tax on buys and sells
* Max wallet of 9% of total supply for first 12 hours
* Higher fee on sells within first 1 hour post-launch
* No team tokens, no presale
* Functions for removing fees
*
SPDX-License-Identifier: UNLICENSED
*/
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract STEAMPUNX is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => User) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e12 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"STEAMPUNX";
string private constant _symbol = unicode"STEAMPUNX";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 6;
uint256 private _teamFee = 4;
uint256 private _feeRate = 2;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
uint256 private _launchFeeEnd;
uint256 private _maxBuyAmount;
uint256 private _maxHeldTokens;
address payable private _feeAddress1;
address payable private _feeAddress2;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _tradingOpen;
bool private _cooldownEnabled = true;
bool private inSwap = false;
bool private _useFees = true;
bool private _useDevFee = true;
uint256 private _buyLimitEnd;
uint256 private _maxHeldTokensEnd;
struct User {
uint256 buy;
uint256 sell;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event UseFeesBooleanUpdated(bool _usefees);
event UseDevFeeBooleanUpdated(bool _usedevfee);
event TaxFeeUpdated(uint _taxfee);
event TeamFeeUpdated(uint _taxfee);
event FeeAddress1Updated(address _feewallet1);
event FeeAddress2Updated(address _feewallet2);
modifier lockTheSwap {
}
constructor (address payable feeAddress1, address payable feeAddress2) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
// set to false for no fee on buys
bool takeFee = true;
if(from != owner() && to != owner()) {
if(_cooldownEnabled) {
if(!cooldown[msg.sender].exists) {
cooldown[msg.sender] = User(0,0,true);
}
}
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
_taxFee = 6;
_teamFee = 4;
require(_tradingOpen, "Trading not yet enabled.");
if(_maxHeldTokensEnd > block.timestamp) {
require(amount.add(balanceOf(address(to))) <= _maxHeldTokens, "You can't own that many tokens at once.");
}
if(_cooldownEnabled) {
if(_buyLimitEnd > block.timestamp) {
require(amount <= _maxBuyAmount);
require(<FILL_ME>)
cooldown[to].buy = block.timestamp + (45 seconds);
}
}
if(_cooldownEnabled) {
cooldown[to].sell = block.timestamp + (15 seconds);
}
}
uint256 contractTokenBalance = balanceOf(address(this));
// sell
if(!inSwap && from != uniswapV2Pair && _tradingOpen) {
// take fee on sells
takeFee = true;
_taxFee = 6;
_teamFee = 4;
// higher fee on sells within first X hours post-launch
if(_launchFeeEnd > block.timestamp) {
_taxFee = 9;
_teamFee = 6;
}
if(_cooldownEnabled) {
require(cooldown[from].sell < block.timestamp, "Your sell cooldown has not expired.");
}
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(_feeRate).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(_feeRate).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(!_useDevFee && _teamFee != 0) {
_teamFee = 0;
}
if(_isExcludedFromFee[from] || _isExcludedFromFee[to] || !_useFees){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function addLiquidity() external onlyOwner() {
}
function openTrading() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function toggleFees() external {
}
function turnOffDevFee() external {
}
function updateFeeAddress1(address newAddress) external {
}
function updateFeeAddress2(address newAddress) external {
}
function setCooldownEnabled() external onlyOwner() {
}
function cooldownEnabled() public view returns (bool) {
}
function timeToBuy(address buyer) public view returns (uint) {
}
function timeToSell(address buyer) public view returns (uint) {
}
function balancePool() public view returns (uint) {
}
function balanceContract() public view returns (uint) {
}
function usingFees() public view returns (bool) {
}
function usingDevFee() public view returns (bool) {
}
function isThereMaxHeld() public view returns (bool) {
}
function whatIsMaxHeld() public view returns (uint256) {
}
function whatIsTaxFee() public view returns (uint256) {
}
function whatIsTeamFee() public view returns (uint256) {
}
function whatIsFeeAddress1() public view returns (address) {
}
function whatIsFeeAddress2() public view returns (address) {
}
}
| cooldown[to].buy<block.timestamp,"Your buy cooldown has not expired." | 290,970 | cooldown[to].buy<block.timestamp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.