comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"You have zero rewards to claim" | // "SPDX-License-Identifier: MIT"
pragma solidity 0.7.3;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface 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 EthanolVault is Ownable {
using SafeMath for uint;
IERC20 public EthanolAddress;
address public admin;
uint public rewardPool;
uint public totalSharedRewards;
mapping(address => uint) private rewardsEarned;
mapping(address => Savings) private _savings;
struct Savings {
address user;
uint startTime;
uint duration;
uint amount;
}
event _LockSavings(
address indexed stakeholder,
uint indexed stake,
uint indexed unlockTime
);
event _UnLockSavings(
address indexed stakeholder,
uint indexed value,
uint indexed timestamp
);
event _RewardShared(
uint indexed timestamp,
uint indexed rewards
);
constructor(IERC20 _EthanolAddress) {
}
function shareReward(address[] memory _accounts, uint[] memory _rewards) public {
}
function checkRewards(address _user) public view returns(uint) {
}
function withdrawRewards(uint _amount) public {
require(<FILL_ME>)
rewardsEarned[_msgSender()] = rewardsEarned[_msgSender()].sub(_amount);
uint _taxedAmount = _amount.mul(10).div(100);
uint _totalBalance = _amount.sub(_taxedAmount);
rewardPool = rewardPool.add(_taxedAmount);
EthanolAddress.transfer(_msgSender(), _totalBalance);
}
function monthlySave(uint _numberOfMonths, uint _amount) public {
}
function yearlySave(uint _amount) public {
}
function timeLock(uint _duration, uint _amount) private {
}
function releaseTokens() public {
}
function getLockedTokens(address _user) external view returns(uint) {
}
receive() external payable {
}
}
| rewardsEarned[_msgSender()]>0,"You have zero rewards to claim" | 375,441 | rewardsEarned[_msgSender()]>0 |
"Funds has already been locked" | // "SPDX-License-Identifier: MIT"
pragma solidity 0.7.3;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface 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 EthanolVault is Ownable {
using SafeMath for uint;
IERC20 public EthanolAddress;
address public admin;
uint public rewardPool;
uint public totalSharedRewards;
mapping(address => uint) private rewardsEarned;
mapping(address => Savings) private _savings;
struct Savings {
address user;
uint startTime;
uint duration;
uint amount;
}
event _LockSavings(
address indexed stakeholder,
uint indexed stake,
uint indexed unlockTime
);
event _UnLockSavings(
address indexed stakeholder,
uint indexed value,
uint indexed timestamp
);
event _RewardShared(
uint indexed timestamp,
uint indexed rewards
);
constructor(IERC20 _EthanolAddress) {
}
function shareReward(address[] memory _accounts, uint[] memory _rewards) public {
}
function checkRewards(address _user) public view returns(uint) {
}
function withdrawRewards(uint _amount) public {
}
function monthlySave(uint _numberOfMonths, uint _amount) public {
}
function yearlySave(uint _amount) public {
}
function timeLock(uint _duration, uint _amount) private {
require(<FILL_ME>)
uint _taxAmount = _amount.mul(4).div(100);
uint _balance = _amount.sub(_taxAmount);
EthanolAddress.transferFrom(_msgSender(), address(this), _amount);
rewardPool = rewardPool.add(_taxAmount);
_savings[_msgSender()] = Savings(
_msgSender(),
block.timestamp,
_duration,
_balance
);
emit _LockSavings(_msgSender(), _balance, block.timestamp);
}
function releaseTokens() public {
}
function getLockedTokens(address _user) external view returns(uint) {
}
receive() external payable {
}
}
| _savings[_msgSender()].amount==0,"Funds has already been locked" | 375,441 | _savings[_msgSender()].amount==0 |
"You have zero savings" | // "SPDX-License-Identifier: MIT"
pragma solidity 0.7.3;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface 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 EthanolVault is Ownable {
using SafeMath for uint;
IERC20 public EthanolAddress;
address public admin;
uint public rewardPool;
uint public totalSharedRewards;
mapping(address => uint) private rewardsEarned;
mapping(address => Savings) private _savings;
struct Savings {
address user;
uint startTime;
uint duration;
uint amount;
}
event _LockSavings(
address indexed stakeholder,
uint indexed stake,
uint indexed unlockTime
);
event _UnLockSavings(
address indexed stakeholder,
uint indexed value,
uint indexed timestamp
);
event _RewardShared(
uint indexed timestamp,
uint indexed rewards
);
constructor(IERC20 _EthanolAddress) {
}
function shareReward(address[] memory _accounts, uint[] memory _rewards) public {
}
function checkRewards(address _user) public view returns(uint) {
}
function withdrawRewards(uint _amount) public {
}
function monthlySave(uint _numberOfMonths, uint _amount) public {
}
function yearlySave(uint _amount) public {
}
function timeLock(uint _duration, uint _amount) private {
}
function releaseTokens() public {
require(
block.timestamp > _savings[_msgSender()].startTime.add(_savings[_msgSender()].duration),
"Unable to withdraw funds while tokens is still locked"
);
require(<FILL_ME>)
uint _amount = _savings[_msgSender()].amount;
_savings[_msgSender()].amount = 0;
if(_savings[_msgSender()].duration >= 365 days) {
uint _rewards = _amount.mul(500).div(100);
_amount = _amount.add(_rewards);
} else {
uint _rewards = _amount.mul(40).div(100);
uint _numberOfMonths = _savings[_msgSender()].duration.div(31 days);
_rewards = _rewards.mul(_numberOfMonths);
_amount = _amount.add(_rewards);
}
rewardPool = rewardPool.sub(_amount);
EthanolAddress.transfer(_msgSender(), _amount);
emit _UnLockSavings(_msgSender(), _amount, block.timestamp);
}
function getLockedTokens(address _user) external view returns(uint) {
}
receive() external payable {
}
}
| _savings[_msgSender()].amount>0,"You have zero savings" | 375,441 | _savings[_msgSender()].amount>0 |
null | /**
* @title EnumerableSet256
* @dev Library containing logic for an enumerable set of uint256 values -- supports checking for presence, adding,
* removing elements, and enumerating elements (without preserving order between mutable operations).
*/
library EnumerableSet256 {
struct Data {
uint256[] elements;
mapping(uint256 => uint256) elementToIndex;
}
/**
* @dev Returns whether the set contains a given element
*
* @param self Data storage Reference to set data
* @param value uint256 Value being checked for existence
* @return bool
*/
function contains(Data storage self, uint256 value) external view returns (bool) {
}
/**
* @dev Adds a new element to the set. Element must not belong to set yet.
*
* @param self Data storage Reference to set data
* @param value uint256 Value being added
*/
function add(Data storage self, uint256 value) external {
uint256 mappingIndex = self.elementToIndex[value];
require(<FILL_ME>)
self.elementToIndex[value] = uint256(self.elements.length);
self.elements.push(value);
}
/**
* @dev Removes an element from the set. Element must already belong to set yet.
*
* @param self Data storage Reference to set data
* @param value uint256 Value being added
*/
function remove(Data storage self, uint256 value) external {
}
/**
* @dev Gets the number of elements on the set.
*
* @param self Data storage Reference to set data
* @return uint256
*/
function size(Data storage self) external view returns (uint256) {
}
/**
* @dev Gets the N-th element from the set, 0-indexed. Note that the ordering is not necessarily consistent
* before and after add, remove operations.
*
* @param self Data storage Reference to set data
* @param index uint256 0-indexed position of the element being queried
* @return uint256
*/
function get(Data storage self, uint256 index) external view returns (uint256) {
}
/**
* @dev Mark the set as empty (not containing any further elements).
*
* @param self Data storage Reference to set data
*/
function clear(Data storage self) external {
}
}
| !((mappingIndex<self.elements.length)&&(self.elements[mappingIndex]==value)) | 375,451 | !((mappingIndex<self.elements.length)&&(self.elements[mappingIndex]==value)) |
null | /**
* @title EnumerableSet256
* @dev Library containing logic for an enumerable set of uint256 values -- supports checking for presence, adding,
* removing elements, and enumerating elements (without preserving order between mutable operations).
*/
library EnumerableSet256 {
struct Data {
uint256[] elements;
mapping(uint256 => uint256) elementToIndex;
}
/**
* @dev Returns whether the set contains a given element
*
* @param self Data storage Reference to set data
* @param value uint256 Value being checked for existence
* @return bool
*/
function contains(Data storage self, uint256 value) external view returns (bool) {
}
/**
* @dev Adds a new element to the set. Element must not belong to set yet.
*
* @param self Data storage Reference to set data
* @param value uint256 Value being added
*/
function add(Data storage self, uint256 value) external {
}
/**
* @dev Removes an element from the set. Element must already belong to set yet.
*
* @param self Data storage Reference to set data
* @param value uint256 Value being added
*/
function remove(Data storage self, uint256 value) external {
uint256 currentElementIndex = self.elementToIndex[value];
require(<FILL_ME>)
uint256 lastElementIndex = uint256(self.elements.length - 1);
uint256 lastElement = self.elements[lastElementIndex];
self.elements[currentElementIndex] = lastElement;
self.elements[lastElementIndex] = 0;
self.elements.length--;
self.elementToIndex[lastElement] = currentElementIndex;
self.elementToIndex[value] = 0;
}
/**
* @dev Gets the number of elements on the set.
*
* @param self Data storage Reference to set data
* @return uint256
*/
function size(Data storage self) external view returns (uint256) {
}
/**
* @dev Gets the N-th element from the set, 0-indexed. Note that the ordering is not necessarily consistent
* before and after add, remove operations.
*
* @param self Data storage Reference to set data
* @param index uint256 0-indexed position of the element being queried
* @return uint256
*/
function get(Data storage self, uint256 index) external view returns (uint256) {
}
/**
* @dev Mark the set as empty (not containing any further elements).
*
* @param self Data storage Reference to set data
*/
function clear(Data storage self) external {
}
}
| (currentElementIndex<self.elements.length)&&(self.elements[currentElementIndex]==value) | 375,451 | (currentElementIndex<self.elements.length)&&(self.elements[currentElementIndex]==value) |
"Collection is not registered for the merge protocol" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
require(<FILL_ME>)
_;
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| collectionNameToCollectionEntry[name].registered,"Collection is not registered for the merge protocol" | 375,520 | collectionNameToCollectionEntry[name].registered |
"Tag with the given tokenId has already been used in a merge" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
require(<FILL_ME>)
require(!collectionNftIsMerged(collectionName, tokenId), "Nft with the given tokenId has already been used in a merge");
require(hewerClan.ownerOf(tagTokenId) == msg.sender, "Must be the owner of the tag");
require(collectionNameToCollectionEntry[collectionName].collection.ownerOf(tokenId) == msg.sender, "Must be the owner of the nft that is used in a merge");
uint mergedTokenId = totalSupply() + 1;
MergedEntry memory entry = MergedEntry(tagTokenId, tokenId, mergedTokenId, collectionName, true);
tokenIdToMergedEntry[mergedTokenId] = entry;
tagTokenIdToMergedEntry[tagTokenId] = entry;
collectionNftTokenIdToMergedEntry[collectionName][tokenId] = entry;
_safeMint(msg.sender, mergedTokenId);
emit TagMerged(tagTokenId, tokenId, collectionName, mergedTokenId);
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !tagIsMerged(tagTokenId),"Tag with the given tokenId has already been used in a merge" | 375,520 | !tagIsMerged(tagTokenId) |
"Nft with the given tokenId has already been used in a merge" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
require(!tagIsMerged(tagTokenId), "Tag with the given tokenId has already been used in a merge");
require(<FILL_ME>)
require(hewerClan.ownerOf(tagTokenId) == msg.sender, "Must be the owner of the tag");
require(collectionNameToCollectionEntry[collectionName].collection.ownerOf(tokenId) == msg.sender, "Must be the owner of the nft that is used in a merge");
uint mergedTokenId = totalSupply() + 1;
MergedEntry memory entry = MergedEntry(tagTokenId, tokenId, mergedTokenId, collectionName, true);
tokenIdToMergedEntry[mergedTokenId] = entry;
tagTokenIdToMergedEntry[tagTokenId] = entry;
collectionNftTokenIdToMergedEntry[collectionName][tokenId] = entry;
_safeMint(msg.sender, mergedTokenId);
emit TagMerged(tagTokenId, tokenId, collectionName, mergedTokenId);
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !collectionNftIsMerged(collectionName,tokenId),"Nft with the given tokenId has already been used in a merge" | 375,520 | !collectionNftIsMerged(collectionName,tokenId) |
"Must be the owner of the tag" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
require(!tagIsMerged(tagTokenId), "Tag with the given tokenId has already been used in a merge");
require(!collectionNftIsMerged(collectionName, tokenId), "Nft with the given tokenId has already been used in a merge");
require(<FILL_ME>)
require(collectionNameToCollectionEntry[collectionName].collection.ownerOf(tokenId) == msg.sender, "Must be the owner of the nft that is used in a merge");
uint mergedTokenId = totalSupply() + 1;
MergedEntry memory entry = MergedEntry(tagTokenId, tokenId, mergedTokenId, collectionName, true);
tokenIdToMergedEntry[mergedTokenId] = entry;
tagTokenIdToMergedEntry[tagTokenId] = entry;
collectionNftTokenIdToMergedEntry[collectionName][tokenId] = entry;
_safeMint(msg.sender, mergedTokenId);
emit TagMerged(tagTokenId, tokenId, collectionName, mergedTokenId);
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| hewerClan.ownerOf(tagTokenId)==msg.sender,"Must be the owner of the tag" | 375,520 | hewerClan.ownerOf(tagTokenId)==msg.sender |
"Must be the owner of the nft that is used in a merge" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
require(!tagIsMerged(tagTokenId), "Tag with the given tokenId has already been used in a merge");
require(!collectionNftIsMerged(collectionName, tokenId), "Nft with the given tokenId has already been used in a merge");
require(hewerClan.ownerOf(tagTokenId) == msg.sender, "Must be the owner of the tag");
require(<FILL_ME>)
uint mergedTokenId = totalSupply() + 1;
MergedEntry memory entry = MergedEntry(tagTokenId, tokenId, mergedTokenId, collectionName, true);
tokenIdToMergedEntry[mergedTokenId] = entry;
tagTokenIdToMergedEntry[tagTokenId] = entry;
collectionNftTokenIdToMergedEntry[collectionName][tokenId] = entry;
_safeMint(msg.sender, mergedTokenId);
emit TagMerged(tagTokenId, tokenId, collectionName, mergedTokenId);
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| collectionNameToCollectionEntry[collectionName].collection.ownerOf(tokenId)==msg.sender,"Must be the owner of the nft that is used in a merge" | 375,520 | collectionNameToCollectionEntry[collectionName].collection.ownerOf(tokenId)==msg.sender |
"Merge request with the given parameters has already been merged" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
require(unmergeAllowed, "Merging the request is only allowed when the unmerge feature is enabled");
require(<FILL_ME>)
MergedEntry storage entry = tokenIdToMergedEntry[mergedTokenId];
entry.merged = true;
entry.collectionName = collectionName;
entry.tokenId = collectionTokenId;
entry.tagTokenId = tagTokenId;
emit TagMerged(tagTokenId, collectionTokenId, collectionName, mergedTokenId);
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !tokenIdToMergedEntry[mergedTokenId].merged,"Merge request with the given parameters has already been merged" | 375,520 | !tokenIdToMergedEntry[mergedTokenId].merged |
"Merge request with the given parameters has already been merged" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
require(unmergeAllowed, "Unmerging the request is not allowed");
require(<FILL_ME>)
MergedEntry storage entry = tokenIdToMergedEntry[tokenId];
entry.merged = false;
tagTokenIdToMergedEntry[entry.tagTokenId].merged = false;
collectionNftTokenIdToMergedEntry[entry.collectionName][entry.tokenId].merged = false;
emit TagUnmerged(entry.tagTokenId, entry.tokenId, entry.collectionName, entry.mergedTokenId);
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| tokenIdToMergedEntry[tokenId].merged,"Merge request with the given parameters has already been merged" | 375,520 | tokenIdToMergedEntry[tokenId].merged |
"Adding already existing collection" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Collection.sol";
contract HewerClanMergeProtocol is Ownable, ERC721Enumerable {
struct CollectionEntry {
bool registered;
Collection collection;
}
struct MergedEntry {
uint256 tagTokenId;
uint256 tokenId;
uint256 mergedTokenId;
string collectionName;
bool merged;
}
Collection public hewerClan;
string public baseUri;
bool public unmergeAllowed;
string [] collections;
mapping(string => CollectionEntry) collectionNameToCollectionEntry;
mapping(uint256 => MergedEntry) tokenIdToMergedEntry;
mapping(string => mapping(uint256 => MergedEntry)) collectionNftTokenIdToMergedEntry;
mapping(uint256 => MergedEntry) tagTokenIdToMergedEntry;
modifier onlyRegisteredCollection(string memory name) {
}
modifier onlyOwnerOf(uint256 tokenId) {
}
event TagMerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
event TagUnmerged(uint256 tagTokenId, uint256 tokenId, string collectionName, uint256 mergedTokenId);
constructor(string memory uri, address hewerClanContractAddress, string [] memory supportedCollections) ERC721("HewerClanMergeProtocol", "HCMP") {
}
function mintMergeRequest(uint256 tagTokenId, uint256 tokenId, string memory collectionName) public onlyRegisteredCollection(collectionName) {
}
function mergeRequest(
uint256 mergedTokenId,
uint256 tagTokenId,
uint256 collectionTokenId,
string memory collectionName
) public onlyRegisteredCollection(collectionName) onlyOwnerOf(mergedTokenId) {
}
function unmergeRequest(uint256 tokenId) public onlyOwnerOf(tokenId) {
}
function tagIsMerged(uint256 tagTokenId) public view returns (bool) {
}
function collectionNftIsMerged(string memory collectionName, uint256 tokenId) public view returns (bool) {
}
function getSupportedCollections() public view returns (string [] memory) {
}
function getOwnerTagTokenIdsAvailableForMerge(address _owner) public view returns (uint [] memory) {
}
function getOwnerNftTokenIdsAvailableForMerge(address _owner, string memory _name) public view returns (uint [] memory) {
}
function getCollectionNameByMergedTokenId(uint _tokenId) public view returns (string memory) {
}
function getCollectionTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function getTagTokenIdByMergedTokenId(uint _tokenId) public view returns (uint) {
}
function addCollection(string memory name, address _addr) public onlyOwner {
require(<FILL_ME>)
collectionNameToCollectionEntry[name] = CollectionEntry(true, Collection(_addr));
collections.push(name);
}
function getCollectionAddress(string memory name) public view returns (address) {
}
function setCollectionAddress(string memory name, address _addr) public onlyOwner {
}
function collectionIsRegistered(string memory name) public view returns (bool) {
}
function flipCollectionRegisteredState(string memory name) public onlyOwner {
}
function flipUnmergeAllowed() public onlyOwner {
}
function setHewerClanAddress(address _contractAddress) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !collectionIsRegistered(name),"Adding already existing collection" | 375,520 | !collectionIsRegistered(name) |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
require(<FILL_ME>)
_;
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| admin[msg.sender]||!ico | 375,601 | admin[msg.sender]||!ico |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(<FILL_ME>) //prevent transfer from frozen address
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| !frozen[_from] | 375,601 | !frozen[_from] |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
require(<FILL_ME>) //prevent transfer from frozen address
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
_transfer(msg.sender, _to, _value);
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| !frozen[msg.sender] | 375,601 | !frozen[msg.sender] |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
require(_to != 0x0);
require(!frozen[msg.sender]); //prevent transfer from frozen address
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
if(!locked) {
_transfer(msg.sender, _to, _value);
}else{
//prevent transfer from frozen address
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(<FILL_ME>) // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalLockedRewardsOf[_to] += _value; // Add the same to the recipient
lockedRewardsOf[_to][msg.sender] += _value;
if(userRewardCount[_to][msg.sender]==0) {
userRewarderCount[_to] += 1;
userRewarders[_to][userRewarderCount[_to]]=msg.sender;
}
userRewardCount[_to][msg.sender]+=1;
totalRewardIssuedOut[msg.sender]+= _value;
Transfer(msg.sender, _to, _value);
}
Reward(msg.sender, _to, _value, data, now);
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| totalLockedRewardsOf[_to]+_value>totalLockedRewardsOf[_to] | 375,601 | totalLockedRewardsOf[_to]+_value>totalLockedRewardsOf[_to] |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
require(!frozen[msg.sender]); //prevent transfer from frozen address
require(<FILL_ME>)
require(totalLockedRewardsOf[msg.sender] >= _value);
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
totalLockedRewardsOf[msg.sender] -= _value; // Add the same to the recipient
lockedRewardsOf[msg.sender][_to] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| lockedRewardsOf[msg.sender][_to]>=_value | 375,601 | lockedRewardsOf[msg.sender][_to]>=_value |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
require(!frozen[msg.sender]); //prevent transfer from frozen address
require(lockedRewardsOf[msg.sender][_to] >= _value );
require(<FILL_ME>)
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
totalLockedRewardsOf[msg.sender] -= _value; // Add the same to the recipient
lockedRewardsOf[msg.sender][_to] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| totalLockedRewardsOf[msg.sender]>=_value | 375,601 | totalLockedRewardsOf[msg.sender]>=_value |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
require(<FILL_ME>) //prevent transfer from frozen address
require(lockedRewardsOf[addr][msg.sender] >= _value );
if(_value==0) _value=lockedRewardsOf[addr][msg.sender];
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
totalLockedRewardsOf[addr] -= _value; // Add the same to the recipient
lockedRewardsOf[addr][msg.sender] -= _value;
balanceOf[addr] += _value;
Unlock(addr, msg.sender, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| totalLockedRewardsOf[addr]>_value | 375,601 | totalLockedRewardsOf[addr]>_value |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
require(totalLockedRewardsOf[addr] > _value); //prevent transfer from frozen address
require(<FILL_ME>)
if(_value==0) _value=lockedRewardsOf[addr][msg.sender];
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
totalLockedRewardsOf[addr] -= _value; // Add the same to the recipient
lockedRewardsOf[addr][msg.sender] -= _value;
balanceOf[addr] += _value;
Unlock(addr, msg.sender, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| lockedRewardsOf[addr][msg.sender]>=_value | 375,601 | lockedRewardsOf[addr][msg.sender]>=_value |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
mapping (address => bool) public admins;
function owned() {
}
modifier onlyOwner {
}
modifier onlyAdmin {
}
function transferOwnership(address newOwner) onlyOwner {
}
function makeAdmin(address newAdmin, bool isAdmin) onlyOwner {
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract ETD is owned {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 minBalanceForAccounts;
bool public usersCanTrade;
bool public usersCanUnfreeze;
bool public ico = true; //turn ico on and of
mapping (address => bool) public admin;
modifier notICO {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozen;
mapping (address => bool) public canTrade; //user allowed to buy or sell
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//This generates a public even on the blockhcain when an address is reward
event Reward(address from, address to, uint256 value, string data, uint256 time);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Frozen(address indexed addr, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Unlock(address indexed addr, address from, uint256 val);
// This generates a public event on the blockchain that will notify clients
// This generates a public event on the blockchain that will notify clients
// event Unfreeze(address indexed addr);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function ETD() {
}
/**
* Increace Total Supply
*
* Increases the total coin supply
*/
function increaseTotalSupply (address target, uint256 increaseBy ) onlyOwner {
}
function usersCanUnFreeze(bool can) {
}
function setMinBalance(uint minimumBalanceInWei) onlyOwner {
}
/**
* transferAndFreeze
*
* Function to transfer to and freeze and account at the same time
*/
function transferAndFreeze (address target, uint256 amount ) onlyAdmin {
}
/**
* _freeze internal
*
* function to freeze an account
*/
function _freeze (address target, bool froze ) internal {
}
/**
* freeze
*
* function to freeze an account
*/
function freeze (address target, bool froze ) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) notICO {
}
mapping (address => uint256) public totalLockedRewardsOf;
mapping (address => mapping (address => uint256)) public lockedRewardsOf; //balance of a locked reward
mapping (address => mapping (uint32 => address)) public userRewarders; //indexed list of rewardees rewarder
mapping (address => mapping (address => uint32)) public userRewardCount; //a list of number of times a customer has received reward from a given merchant
mapping (address => uint32) public userRewarderCount; //number of rewarders per customer
//merchant
mapping (address => uint256 ) public totalRewardIssuedOut;
/**
* Reward tokens - tokens go to
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function reward(address _to, uint256 _value, bool locked, string data) {
}
/**
* Transfer locked rewards
*
* Send `_value` tokens to `_to` merchant
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferReward(address _to, uint256 _value) {
}
/**
* Unlocked locked rewards by merchant
*
* Unlock `_value` tokens of `add`
*
* @param addr The address of the recipient
* @param _value the amount to unlock
*/
function unlockReward(address addr, uint256 _value) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value)
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) onlyOwner
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner returns (bool success) {
}
/**
* Destroy tokens from other ccount
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) returns (bool success) {
}
/*
function increaseSupply(address _from, uint256 _value) onlyOwner returns (bool success) {
balanceOf[_from] += _value; // Subtract from the targeted balance
totalSupply += _value; // Update totalSupply
// Burn(_from, _value);
return true;
}
*/
uint256 public sellPrice = 608;
uint256 public buyPrice = 760;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
}
function setUsersCanTrade(bool trade) onlyOwner {
}
function setCanTrade(address addr, bool trade) onlyOwner {
}
//user is buying etd
function buy() payable returns (uint256 amount){
}
//user is selling us etd, we are selling eth to the user
function sell(uint256 amount) returns (uint revenue){
require(!frozen[msg.sender]);
if(!usersCanTrade && !canTrade[msg.sender]) {
require(minBalanceForAccounts > amount/sellPrice);
}
require(balanceOf[msg.sender] >= amount); // checks if the sender has enough to sell
balanceOf[this] += amount; // adds the amount to owner's balance
balanceOf[msg.sender] -= amount; // subtracts the amount from seller's balance
revenue = amount / sellPrice;
require(<FILL_ME>) // sends ether to the seller: it's important to do this last to prevent recursion attacks
Transfer(msg.sender, this, amount); // executes an event reflecting on the change
return revenue; // ends function and returns
}
function() payable {
}
event Withdrawn(address indexed to, uint256 value);
function withdraw(address target, uint256 amount) onlyOwner {
}
function setAdmin(address addr, bool enabled) onlyOwner {
}
function setICO(bool enabled) onlyOwner {
}
}
| msg.sender.send(revenue) | 375,601 | msg.sender.send(revenue) |
null | pragma solidity ^0.4.16;
/// @title SafeMath
/// @dev Math operations with safety checks that throw on error
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
/// @title ERC20 Standard Token interface
contract IERC20Token {
function name() public constant returns (string) { }
function symbol() public constant returns (string) { }
function decimals() public constant returns (uint8) { }
function totalSupply() public constant returns (uint256) { }
function balanceOf(address _owner) public constant returns (uint256 balance) { }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { }
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
}
/// @title ERC20 Standard Token implementation
contract ERC20Token is IERC20Token {
using SafeMath for uint256;
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
}
modifier validAddress(address _address) {
}
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool) {
}
}
contract IOwned {
function owner() public constant returns (address) { }
function transferOwnership(address _newOwner) public;
}
contract Owned is IOwned {
address public owner;
function Owned() {
}
modifier validAddress(address _address) {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) validAddress(_newOwner) onlyOwner {
}
}
/// @title BXN contract interface
contract ISmartToken {
function initialSupply() public constant returns (uint256) { }
function totalSoldTokens() public constant returns (uint256) { }
function totalProjectToken() public constant returns (uint256) { }
function fundingEnabled() public constant returns (bool) { }
function transfersEnabled() public constant returns (bool) { }
}
/// @title BXN contract - crowdfunding code for BXN Project
contract SmartToken is ISmartToken, ERC20Token, Owned {
using SafeMath for uint256;
// The current initial token supply.
uint256 public initialSupply = 80000000 ether;
// Cold wallet for distribution of tokens.
address public fundingWallet;
// The flag indicates if the BXN contract is in Funding state.
bool public fundingEnabled = true;
// The maximum tokens available for sale.
uint256 public maxSaleToken;
// Total number of tokens sold.
uint256 public totalSoldTokens;
// Total number of tokens for BXN Project.
uint256 public totalProjectToken;
uint256 private totalLockToken;
// The flag indicates if the BXN contract is in eneble / disable transfers.
bool public transfersEnabled = true;
// Wallets, which allowed the transaction during the crowdfunding.
mapping (address => bool) private fundingWallets;
// Wallets B2BX Project, which will be locked the tokens
mapping (address => allocationLock) public allocations;
struct allocationLock {
uint256 value;
uint256 end;
bool locked;
}
event Finalize(address indexed _from, uint256 _value);
event Lock(address indexed _from, address indexed _to, uint256 _value, uint256 _end);
event Unlock(address indexed _from, address indexed _to, uint256 _value);
event DisableTransfers(address indexed _from);
/// @notice BXN Project - Initializing crowdfunding.
/// @dev Constructor.
function SmartToken() ERC20Token("BITTXN", "BXN", 18) {
}
// Validates an address - currently only checks that it isn't null.
modifier validAddress(address _address) {
}
modifier transfersAllowed(address _address) {
if (fundingEnabled) {
require(<FILL_ME>)
}
require(transfersEnabled);
_;
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send tokens.
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transfer(address _to, uint256 _value) public validAddress(_to) transfersAllowed(msg.sender) returns (bool) {
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send from tokens.
/// @param _from address The address of the sender of the token
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) transfersAllowed(_from) returns (bool) {
}
/// @notice This function can accept for blocking no more than "totalProjectToken".
/// @dev Lock tokens to a specified address.
/// @param _to address The address to lock tokens to.
/// @param _value uint256 The amount of tokens to be locked.
/// @param _end uint256 The end of the lock period.
function lock(address _to, uint256 _value, uint256 _end) internal validAddress(_to) onlyOwner returns (bool) {
}
/// @notice Only the owner of a locked wallet can unlock the tokens.
/// @dev Unlock tokens at the address to the caller function.
function unlock() external {
}
/// @notice BXN Allocation - finalize crowdfunding & time-locked vault of tokens allocated
/// to BXN company, developers and Airdrop program.
function finalize() external onlyOwner {
}
/// @notice Disable all transfers in case of a vulnerability found in the contract or other systems.
/// @dev Disable transfers in BXN contract.
function disableTransfers() external onlyOwner {
}
function enableTransfers() external onlyOwner {
}
/// @dev Disable the hot wallets for transfers.
/// @param _address address Address in fundingWallets[]
function disableFundingWallets(address _address) external onlyOwner {
}
}
| fundingWallets[_address] | 375,662 | fundingWallets[_address] |
null | pragma solidity ^0.4.16;
/// @title SafeMath
/// @dev Math operations with safety checks that throw on error
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
/// @title ERC20 Standard Token interface
contract IERC20Token {
function name() public constant returns (string) { }
function symbol() public constant returns (string) { }
function decimals() public constant returns (uint8) { }
function totalSupply() public constant returns (uint256) { }
function balanceOf(address _owner) public constant returns (uint256 balance) { }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { }
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
}
/// @title ERC20 Standard Token implementation
contract ERC20Token is IERC20Token {
using SafeMath for uint256;
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
}
modifier validAddress(address _address) {
}
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool) {
}
}
contract IOwned {
function owner() public constant returns (address) { }
function transferOwnership(address _newOwner) public;
}
contract Owned is IOwned {
address public owner;
function Owned() {
}
modifier validAddress(address _address) {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) validAddress(_newOwner) onlyOwner {
}
}
/// @title BXN contract interface
contract ISmartToken {
function initialSupply() public constant returns (uint256) { }
function totalSoldTokens() public constant returns (uint256) { }
function totalProjectToken() public constant returns (uint256) { }
function fundingEnabled() public constant returns (bool) { }
function transfersEnabled() public constant returns (bool) { }
}
/// @title BXN contract - crowdfunding code for BXN Project
contract SmartToken is ISmartToken, ERC20Token, Owned {
using SafeMath for uint256;
// The current initial token supply.
uint256 public initialSupply = 80000000 ether;
// Cold wallet for distribution of tokens.
address public fundingWallet;
// The flag indicates if the BXN contract is in Funding state.
bool public fundingEnabled = true;
// The maximum tokens available for sale.
uint256 public maxSaleToken;
// Total number of tokens sold.
uint256 public totalSoldTokens;
// Total number of tokens for BXN Project.
uint256 public totalProjectToken;
uint256 private totalLockToken;
// The flag indicates if the BXN contract is in eneble / disable transfers.
bool public transfersEnabled = true;
// Wallets, which allowed the transaction during the crowdfunding.
mapping (address => bool) private fundingWallets;
// Wallets B2BX Project, which will be locked the tokens
mapping (address => allocationLock) public allocations;
struct allocationLock {
uint256 value;
uint256 end;
bool locked;
}
event Finalize(address indexed _from, uint256 _value);
event Lock(address indexed _from, address indexed _to, uint256 _value, uint256 _end);
event Unlock(address indexed _from, address indexed _to, uint256 _value);
event DisableTransfers(address indexed _from);
/// @notice BXN Project - Initializing crowdfunding.
/// @dev Constructor.
function SmartToken() ERC20Token("BITTXN", "BXN", 18) {
}
// Validates an address - currently only checks that it isn't null.
modifier validAddress(address _address) {
}
modifier transfersAllowed(address _address) {
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send tokens.
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transfer(address _to, uint256 _value) public validAddress(_to) transfersAllowed(msg.sender) returns (bool) {
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send from tokens.
/// @param _from address The address of the sender of the token
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) transfersAllowed(_from) returns (bool) {
}
/// @notice This function can accept for blocking no more than "totalProjectToken".
/// @dev Lock tokens to a specified address.
/// @param _to address The address to lock tokens to.
/// @param _value uint256 The amount of tokens to be locked.
/// @param _end uint256 The end of the lock period.
function lock(address _to, uint256 _value, uint256 _end) internal validAddress(_to) onlyOwner returns (bool) {
require(_value > 0);
assert(totalProjectToken > 0);
// Check that this lock doesn't exceed the total amount of tokens currently available for totalProjectToken.
totalLockToken = totalLockToken.add(_value);
assert(totalProjectToken >= totalLockToken);
// Make sure that a single address can be locked tokens only once.
require(<FILL_ME>)
// Assign a new lock.
allocations[_to] = allocationLock({
value: _value,
end: _end,
locked: true
});
Lock(this, _to, _value, _end);
return true;
}
/// @notice Only the owner of a locked wallet can unlock the tokens.
/// @dev Unlock tokens at the address to the caller function.
function unlock() external {
}
/// @notice BXN Allocation - finalize crowdfunding & time-locked vault of tokens allocated
/// to BXN company, developers and Airdrop program.
function finalize() external onlyOwner {
}
/// @notice Disable all transfers in case of a vulnerability found in the contract or other systems.
/// @dev Disable transfers in BXN contract.
function disableTransfers() external onlyOwner {
}
function enableTransfers() external onlyOwner {
}
/// @dev Disable the hot wallets for transfers.
/// @param _address address Address in fundingWallets[]
function disableFundingWallets(address _address) external onlyOwner {
}
}
| allocations[_to].value==0 | 375,662 | allocations[_to].value==0 |
null | pragma solidity ^0.4.16;
/// @title SafeMath
/// @dev Math operations with safety checks that throw on error
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
/// @title ERC20 Standard Token interface
contract IERC20Token {
function name() public constant returns (string) { }
function symbol() public constant returns (string) { }
function decimals() public constant returns (uint8) { }
function totalSupply() public constant returns (uint256) { }
function balanceOf(address _owner) public constant returns (uint256 balance) { }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { }
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
}
/// @title ERC20 Standard Token implementation
contract ERC20Token is IERC20Token {
using SafeMath for uint256;
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
}
modifier validAddress(address _address) {
}
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool) {
}
}
contract IOwned {
function owner() public constant returns (address) { }
function transferOwnership(address _newOwner) public;
}
contract Owned is IOwned {
address public owner;
function Owned() {
}
modifier validAddress(address _address) {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) validAddress(_newOwner) onlyOwner {
}
}
/// @title BXN contract interface
contract ISmartToken {
function initialSupply() public constant returns (uint256) { }
function totalSoldTokens() public constant returns (uint256) { }
function totalProjectToken() public constant returns (uint256) { }
function fundingEnabled() public constant returns (bool) { }
function transfersEnabled() public constant returns (bool) { }
}
/// @title BXN contract - crowdfunding code for BXN Project
contract SmartToken is ISmartToken, ERC20Token, Owned {
using SafeMath for uint256;
// The current initial token supply.
uint256 public initialSupply = 80000000 ether;
// Cold wallet for distribution of tokens.
address public fundingWallet;
// The flag indicates if the BXN contract is in Funding state.
bool public fundingEnabled = true;
// The maximum tokens available for sale.
uint256 public maxSaleToken;
// Total number of tokens sold.
uint256 public totalSoldTokens;
// Total number of tokens for BXN Project.
uint256 public totalProjectToken;
uint256 private totalLockToken;
// The flag indicates if the BXN contract is in eneble / disable transfers.
bool public transfersEnabled = true;
// Wallets, which allowed the transaction during the crowdfunding.
mapping (address => bool) private fundingWallets;
// Wallets B2BX Project, which will be locked the tokens
mapping (address => allocationLock) public allocations;
struct allocationLock {
uint256 value;
uint256 end;
bool locked;
}
event Finalize(address indexed _from, uint256 _value);
event Lock(address indexed _from, address indexed _to, uint256 _value, uint256 _end);
event Unlock(address indexed _from, address indexed _to, uint256 _value);
event DisableTransfers(address indexed _from);
/// @notice BXN Project - Initializing crowdfunding.
/// @dev Constructor.
function SmartToken() ERC20Token("BITTXN", "BXN", 18) {
}
// Validates an address - currently only checks that it isn't null.
modifier validAddress(address _address) {
}
modifier transfersAllowed(address _address) {
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send tokens.
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transfer(address _to, uint256 _value) public validAddress(_to) transfersAllowed(msg.sender) returns (bool) {
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send from tokens.
/// @param _from address The address of the sender of the token
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) transfersAllowed(_from) returns (bool) {
}
/// @notice This function can accept for blocking no more than "totalProjectToken".
/// @dev Lock tokens to a specified address.
/// @param _to address The address to lock tokens to.
/// @param _value uint256 The amount of tokens to be locked.
/// @param _end uint256 The end of the lock period.
function lock(address _to, uint256 _value, uint256 _end) internal validAddress(_to) onlyOwner returns (bool) {
}
/// @notice Only the owner of a locked wallet can unlock the tokens.
/// @dev Unlock tokens at the address to the caller function.
function unlock() external {
require(<FILL_ME>)
require(now >= allocations[msg.sender].end);
balanceOf[msg.sender] = balanceOf[msg.sender].add(allocations[msg.sender].value);
allocations[msg.sender].locked = false;
Transfer(this, msg.sender, allocations[msg.sender].value);
Unlock(this, msg.sender, allocations[msg.sender].value);
}
/// @notice BXN Allocation - finalize crowdfunding & time-locked vault of tokens allocated
/// to BXN company, developers and Airdrop program.
function finalize() external onlyOwner {
}
/// @notice Disable all transfers in case of a vulnerability found in the contract or other systems.
/// @dev Disable transfers in BXN contract.
function disableTransfers() external onlyOwner {
}
function enableTransfers() external onlyOwner {
}
/// @dev Disable the hot wallets for transfers.
/// @param _address address Address in fundingWallets[]
function disableFundingWallets(address _address) external onlyOwner {
}
}
| allocations[msg.sender].locked | 375,662 | allocations[msg.sender].locked |
null | pragma solidity ^0.4.16;
/// @title SafeMath
/// @dev Math operations with safety checks that throw on error
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
/// @title ERC20 Standard Token interface
contract IERC20Token {
function name() public constant returns (string) { }
function symbol() public constant returns (string) { }
function decimals() public constant returns (uint8) { }
function totalSupply() public constant returns (uint256) { }
function balanceOf(address _owner) public constant returns (uint256 balance) { }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { }
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
}
/// @title ERC20 Standard Token implementation
contract ERC20Token is IERC20Token {
using SafeMath for uint256;
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
}
modifier validAddress(address _address) {
}
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) returns (bool) {
}
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool) {
}
}
contract IOwned {
function owner() public constant returns (address) { }
function transferOwnership(address _newOwner) public;
}
contract Owned is IOwned {
address public owner;
function Owned() {
}
modifier validAddress(address _address) {
}
modifier onlyOwner {
}
function transferOwnership(address _newOwner) validAddress(_newOwner) onlyOwner {
}
}
/// @title BXN contract interface
contract ISmartToken {
function initialSupply() public constant returns (uint256) { }
function totalSoldTokens() public constant returns (uint256) { }
function totalProjectToken() public constant returns (uint256) { }
function fundingEnabled() public constant returns (bool) { }
function transfersEnabled() public constant returns (bool) { }
}
/// @title BXN contract - crowdfunding code for BXN Project
contract SmartToken is ISmartToken, ERC20Token, Owned {
using SafeMath for uint256;
// The current initial token supply.
uint256 public initialSupply = 80000000 ether;
// Cold wallet for distribution of tokens.
address public fundingWallet;
// The flag indicates if the BXN contract is in Funding state.
bool public fundingEnabled = true;
// The maximum tokens available for sale.
uint256 public maxSaleToken;
// Total number of tokens sold.
uint256 public totalSoldTokens;
// Total number of tokens for BXN Project.
uint256 public totalProjectToken;
uint256 private totalLockToken;
// The flag indicates if the BXN contract is in eneble / disable transfers.
bool public transfersEnabled = true;
// Wallets, which allowed the transaction during the crowdfunding.
mapping (address => bool) private fundingWallets;
// Wallets B2BX Project, which will be locked the tokens
mapping (address => allocationLock) public allocations;
struct allocationLock {
uint256 value;
uint256 end;
bool locked;
}
event Finalize(address indexed _from, uint256 _value);
event Lock(address indexed _from, address indexed _to, uint256 _value, uint256 _end);
event Unlock(address indexed _from, address indexed _to, uint256 _value);
event DisableTransfers(address indexed _from);
/// @notice BXN Project - Initializing crowdfunding.
/// @dev Constructor.
function SmartToken() ERC20Token("BITTXN", "BXN", 18) {
}
// Validates an address - currently only checks that it isn't null.
modifier validAddress(address _address) {
}
modifier transfersAllowed(address _address) {
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send tokens.
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transfer(address _to, uint256 _value) public validAddress(_to) transfersAllowed(msg.sender) returns (bool) {
}
/// @notice This function is disabled during the crowdfunding.
/// @dev Send from tokens.
/// @param _from address The address of the sender of the token
/// @param _to address The address of the tokens recipient.
/// @param _value _value The amount of token to be transferred.
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) transfersAllowed(_from) returns (bool) {
}
/// @notice This function can accept for blocking no more than "totalProjectToken".
/// @dev Lock tokens to a specified address.
/// @param _to address The address to lock tokens to.
/// @param _value uint256 The amount of tokens to be locked.
/// @param _end uint256 The end of the lock period.
function lock(address _to, uint256 _value, uint256 _end) internal validAddress(_to) onlyOwner returns (bool) {
}
/// @notice Only the owner of a locked wallet can unlock the tokens.
/// @dev Unlock tokens at the address to the caller function.
function unlock() external {
}
/// @notice BXN Allocation - finalize crowdfunding & time-locked vault of tokens allocated
/// to BXN company, developers and Airdrop program.
function finalize() external onlyOwner {
}
/// @notice Disable all transfers in case of a vulnerability found in the contract or other systems.
/// @dev Disable transfers in BXN contract.
function disableTransfers() external onlyOwner {
}
function enableTransfers() external onlyOwner {
require(<FILL_ME>)
transfersEnabled = !false;
DisableTransfers(msg.sender);
}
/// @dev Disable the hot wallets for transfers.
/// @param _address address Address in fundingWallets[]
function disableFundingWallets(address _address) external onlyOwner {
}
}
| !transfersEnabled | 375,662 | !transfersEnabled |
null | pragma solidity ^0.6.0;
import "./ERC1155.sol";
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/**
@dev Mintable form of ERC1155
Shows how easy it is to mint new items.
*/
contract ERC1155Mintable is ERC1155 ,Ownable{
bytes4 constant private INTERFACE_SIGNATURE_URI = 0x0e89341c;
// id => creators
mapping (uint256 => address) public creators;
mapping(uint256 => string) public tokenUris;
// A nonce to ensure we have a unique id each time we mint.
uint256 public nonce;
modifier creatorOnly(uint256 _id) {
require(<FILL_ME>)
_;
}
function supportsInterface(bytes4 _interfaceId) override
public
view
returns (bool) {
}
// Creates a new token type and assings _initialSupply to minter
function create(uint256 _initialSupply, string calldata _uri) external onlyOwner returns(uint256 _id) {
}
// Batch mint tokens. Assign directly to _to[].
function mint(uint256 _id, address[] calldata _to, uint256[] calldata _quantities) external onlyOwner{
}
//mint tokens. Assign directly to _to[].
function mintSingle(uint256 _id, address _to, uint256 _quantities) external onlyOwner {
}
function setURI(string calldata _uri, uint256 _id) external onlyOwner {
}
function uri(uint256 _id) public view returns (string memory uri) {
}
}
| creators[_id]==msg.sender | 375,839 | creators[_id]==msg.sender |
"This address is not allowed to interact with the contract" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC20.sol";
import "./Ownable.sol";
contract RCC is ERC20("Royal Ceramic Club ERC20 Token", "$RCC"), Ownable {
mapping(address => bool) public managers;
function addManager(address _address) external onlyOwner {
}
function removeManager(address _address) external onlyOwner {
}
function mint(address _to, uint256 _amount) external {
}
function burn(address _from, uint256 _amount) external {
require(<FILL_ME>)
_burn(_from, _amount);
}
}
| managers[msg.sender]==true||msg.sender==_from,"This address is not allowed to interact with the contract" | 375,925 | managers[msg.sender]==true||msg.sender==_from |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract MultiTokenBasics {
function totalSupply(uint256 _tokenId) public view returns (uint256);
function balanceOf(uint256 _tokenId, address _owner) public view returns (uint256);
function allowance(uint256 _tokenId, address _owner, address _spender) public view returns (uint256);
function transfer(uint256 _tokenId, address _to, uint256 _value) public returns (bool);
function transferFrom(uint256 _tokenId, address _from, address _to, uint256 _value) public returns (bool);
function approve(uint256 _tokenId, address _spender, uint256 _value) public returns (bool);
event Transfer(uint256 indexed tokenId, address indexed from, address indexed to, uint256 value);
event Approval(uint256 indexed tokenId, address indexed owner, address indexed spender, uint256 value);
}
contract MultiToken is Ownable, MultiTokenBasics {
using SafeMath for uint256;
mapping(uint256 => mapping(address => mapping(address => uint256))) private allowed;
mapping(uint256 => mapping(address => uint256)) private balance;
mapping(uint256 => uint256) private totalSupply_;
uint8 public decimals = 18;
uint256 public mask = 0xffffffff;
/**
* @dev Throws if _tokenId not exists
* @param _tokenId uint256 is subtoken identifier
*/
modifier existingToken(uint256 _tokenId) {
require(<FILL_ME>)
_;
}
/**
* @dev Throws if _tokenId exists
* @param _tokenId uint256 is subtoken identifier
*/
modifier notExistingToken(uint256 _tokenId) {
}
/**
* @dev create new subtoken with unique tokenId
* @param _tokenId uint256 is subtoken identifier
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
* @return uint256 representing the total amount of tokens
*/
function createNewSubtoken(uint256 _tokenId, address _to, uint256 _value) notExistingToken(_tokenId) onlyOwner() public returns (bool) {
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @param _tokenId uint256 is subtoken identifier
* @return uint256 representing the total amount of tokens
*/
function totalSupply(uint256 _tokenId) existingToken(_tokenId) public view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address
* @param _tokenId uint256 is subtoken identifier
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(uint256 _tokenId, address _owner) existingToken(_tokenId) public view returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _tokenId uint256 is subtoken identifier
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(uint256 _tokenId, address _owner, address _spender) existingToken(_tokenId) public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _tokenId uint256 is subtoken identifier
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(uint256 _tokenId, address _to, uint256 _value) existingToken(_tokenId) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _tokenId uint256 is subtoken identifier
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(uint256 _tokenId, address _from, address _to, uint256 _value) existingToken(_tokenId) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _tokenId uint256 is subtoken identifier
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(uint256 _tokenId, address _spender, uint256 _value) public returns (bool) {
}
}
| totalSupply_[_tokenId]>0&&(_tokenId&mask==_tokenId) | 376,035 | totalSupply_[_tokenId]>0&&(_tokenId&mask==_tokenId) |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract MultiTokenBasics {
function totalSupply(uint256 _tokenId) public view returns (uint256);
function balanceOf(uint256 _tokenId, address _owner) public view returns (uint256);
function allowance(uint256 _tokenId, address _owner, address _spender) public view returns (uint256);
function transfer(uint256 _tokenId, address _to, uint256 _value) public returns (bool);
function transferFrom(uint256 _tokenId, address _from, address _to, uint256 _value) public returns (bool);
function approve(uint256 _tokenId, address _spender, uint256 _value) public returns (bool);
event Transfer(uint256 indexed tokenId, address indexed from, address indexed to, uint256 value);
event Approval(uint256 indexed tokenId, address indexed owner, address indexed spender, uint256 value);
}
contract MultiToken is Ownable, MultiTokenBasics {
using SafeMath for uint256;
mapping(uint256 => mapping(address => mapping(address => uint256))) private allowed;
mapping(uint256 => mapping(address => uint256)) private balance;
mapping(uint256 => uint256) private totalSupply_;
uint8 public decimals = 18;
uint256 public mask = 0xffffffff;
/**
* @dev Throws if _tokenId not exists
* @param _tokenId uint256 is subtoken identifier
*/
modifier existingToken(uint256 _tokenId) {
}
/**
* @dev Throws if _tokenId exists
* @param _tokenId uint256 is subtoken identifier
*/
modifier notExistingToken(uint256 _tokenId) {
require(<FILL_ME>)
_;
}
/**
* @dev create new subtoken with unique tokenId
* @param _tokenId uint256 is subtoken identifier
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
* @return uint256 representing the total amount of tokens
*/
function createNewSubtoken(uint256 _tokenId, address _to, uint256 _value) notExistingToken(_tokenId) onlyOwner() public returns (bool) {
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @param _tokenId uint256 is subtoken identifier
* @return uint256 representing the total amount of tokens
*/
function totalSupply(uint256 _tokenId) existingToken(_tokenId) public view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address
* @param _tokenId uint256 is subtoken identifier
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(uint256 _tokenId, address _owner) existingToken(_tokenId) public view returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _tokenId uint256 is subtoken identifier
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(uint256 _tokenId, address _owner, address _spender) existingToken(_tokenId) public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _tokenId uint256 is subtoken identifier
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(uint256 _tokenId, address _to, uint256 _value) existingToken(_tokenId) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _tokenId uint256 is subtoken identifier
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(uint256 _tokenId, address _from, address _to, uint256 _value) existingToken(_tokenId) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _tokenId uint256 is subtoken identifier
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(uint256 _tokenId, address _spender, uint256 _value) public returns (bool) {
}
}
| totalSupply_[_tokenId]==0&&(_tokenId&mask==_tokenId) | 376,035 | totalSupply_[_tokenId]==0&&(_tokenId&mask==_tokenId) |
null | /**
* The main body of final smart contract
*/
contract ParcelXToken is ERC20, MultiOwnable, Pausable, Convertible {
using SafeMath for uint256;
string public constant name = "TestGPXv2";
string public constant symbol = "TestGPXv2";
uint8 public constant decimals = 18;
uint256 public constant TOTAL_SUPPLY = uint256(1000000000) * (uint256(10) ** decimals); // 10,0000,0000
address internal tokenPool; // Use a token pool holding all GPX. Avoid using sender address.
mapping(address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function ParcelXToken(address[] _multiOwners, uint _multiRequires)
MultiOwnable(_multiOwners, _multiRequires) public {
}
/**
* FEATURE 1): ERC20 implementation
*/
function totalSupply() public view returns (uint256) {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
/**
* FEATURE 4): Buyable implements
* 0.000268 eth per GPX, so the rate is 1.0 / 0.000268 = 3731.3432835820895
*/
uint256 internal buyRate = uint256(3731);
event Deposit(address indexed who, uint256 value);
event Withdraw(address indexed who, uint256 value, address indexed lastApprover, string extra);
function getBuyRate() external view returns (uint256) {
}
function setBuyRate(uint256 newBuyRate) mostOwner(keccak256(msg.data)) external {
}
/**
* FEATURE 4): Buyable
* minimum of 0.001 ether for purchase in the public, pre-ico, and private sale
*/
function buy() payable whenNotPaused public returns (uint256) {
Deposit(msg.sender, msg.value);
require(msg.value >= 0.001 ether);
// Token compute & transfer
uint256 tokens = msg.value.mul(buyRate);
require(<FILL_ME>)
balances[tokenPool] = balances[tokenPool].sub(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
Transfer(tokenPool, msg.sender, tokens);
return tokens;
}
// gets called when no other function matches
function () payable public {
}
function execute(address _to, uint256 _value, string _extra) mostOwner(keccak256(msg.data)) external returns (bool){
}
/**
* FEATURE 5): Convertible implements
*/
function convertMainchainGPX(string destinationAccount, string extra) external returns (bool) {
}
}
| balances[tokenPool]>=tokens | 376,089 | balances[tokenPool]>=tokens |
null | /**
* The main body of final smart contract
*/
contract ParcelXToken is ERC20, MultiOwnable, Pausable, Convertible {
using SafeMath for uint256;
string public constant name = "TestGPXv2";
string public constant symbol = "TestGPXv2";
uint8 public constant decimals = 18;
uint256 public constant TOTAL_SUPPLY = uint256(1000000000) * (uint256(10) ** decimals); // 10,0000,0000
address internal tokenPool; // Use a token pool holding all GPX. Avoid using sender address.
mapping(address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function ParcelXToken(address[] _multiOwners, uint _multiRequires)
MultiOwnable(_multiOwners, _multiRequires) public {
}
/**
* FEATURE 1): ERC20 implementation
*/
function totalSupply() public view returns (uint256) {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
/**
* FEATURE 4): Buyable implements
* 0.000268 eth per GPX, so the rate is 1.0 / 0.000268 = 3731.3432835820895
*/
uint256 internal buyRate = uint256(3731);
event Deposit(address indexed who, uint256 value);
event Withdraw(address indexed who, uint256 value, address indexed lastApprover, string extra);
function getBuyRate() external view returns (uint256) {
}
function setBuyRate(uint256 newBuyRate) mostOwner(keccak256(msg.data)) external {
}
/**
* FEATURE 4): Buyable
* minimum of 0.001 ether for purchase in the public, pre-ico, and private sale
*/
function buy() payable whenNotPaused public returns (uint256) {
}
// gets called when no other function matches
function () payable public {
}
function execute(address _to, uint256 _value, string _extra) mostOwner(keccak256(msg.data)) external returns (bool){
}
/**
* FEATURE 5): Convertible implements
*/
function convertMainchainGPX(string destinationAccount, string extra) external returns (bool) {
require(<FILL_ME>)
require(balances[msg.sender] > 0);
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0;
balances[tokenPool] = balances[tokenPool].add(amount); // recycle ParcelX to tokenPool's init account
Converted(msg.sender, destinationAccount, amount, extra);
return true;
}
}
| bytes(destinationAccount).length>10&&bytes(destinationAccount).length<128 | 376,089 | bytes(destinationAccount).length>10&&bytes(destinationAccount).length<128 |
"token transfer failure" | // SPDX-License-Identifier: MIT
pragma solidity ^0.5.12;
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libs/IERC20.sol";
import "./libs/IERC1620.sol";
import "./libs/CarefulMath.sol";
import "./libs/Types.sol";
contract MeVesting is IERC1620, ReentrancyGuard, CarefulMath {
/*** Storage Properties ***/
/// @notice check to enable stream withdrawals
bool public withdrawable;
/// @notice address that can enable withdrawals
address public gov;
/**
* @notice Counter for new stream ids.
*/
uint256 public nextStreamId;
/**
* @notice The stream objects identifiable by their unsigned integer ids.
*/
mapping(uint256 => Types.Stream) private streams;
/*** Modifiers ***/
/**
* @dev Throws if the caller is not the sender of the recipient of the stream.
*/
modifier onlySenderOrRecipient(uint256 streamId) {
}
/**
* @dev Throws if the provided id does not point to a valid stream.
*/
modifier streamExists(uint256 streamId) {
}
/*** Contract Logic Starts Here */
constructor() public {
}
/*** View Functions ***/
/**
* @notice Returns the compounding stream with all its properties.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream to query.
* @return The stream object as an array of info.
*/
function getStream(uint256 streamId)
external
view
streamExists(streamId)
returns (
address sender,
address recipient,
uint256 deposit,
address tokenAddress,
uint256 startTime,
uint256 stopTime,
uint256 remainingBalance,
uint256 ratePerSecond
)
{
}
/**
* @notice Returns either the delta in seconds between `block.timestamp` and `startTime` or
* between `stopTime` and `startTime, whichever is smaller. If `block.timestamp` is before
* `startTime`, it returns 0.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the delta.
* @return The time delta in seconds.
*/
function deltaOf(uint256 streamId) public view streamExists(streamId) returns (uint256 delta) {
}
struct BalanceOfLocalVars {
MathError mathErr;
uint256 recipientBalance;
uint256 withdrawalAmount;
uint256 senderBalance;
}
/**
* @notice Returns the available funds for the given stream id and address.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the balance.
* @param who The address for which to query the balance.
* @return The total funds allocated to `who` as uint256.
*/
function balanceOf(uint256 streamId, address who) public view streamExists(streamId) returns (uint256 balance) {
}
/*** Public Effects & Interactions Functions ***/
struct CreateStreamLocalVars {
MathError mathErr;
uint256 duration;
uint256 ratePerSecond;
}
/**
* @notice Creates a new stream funded by `msg.sender` and paid towards `recipient`.
* @dev Throws if paused.
* Throws if the recipient is the zero address, the contract itself or the caller.
* Throws if the deposit is 0.
* Throws if the start time is before `block.timestamp`.
* Throws if the stop time is before the start time.
* Throws if the duration calculation has a math error.
* Throws if the deposit is smaller than the duration.
* Throws if the deposit is not a multiple of the duration.
* Throws if the rate calculation has a math error.
* Throws if the next stream id calculation has a math error.
* Throws if the contract is not allowed to transfer enough tokens.
* Throws if there is a token transfer failure.
* @param recipient The address towards which the money is streamed.
* @param deposit The amount of money to be streamed.
* @param tokenAddress The ERC20 token to use as streaming currency.
* @param startTime The unix timestamp for when the stream starts accumulating a pending stream balance.
* @param stopTime The unix timestamp for when the stream stops.
* @return The uint256 id of the newly created stream.
*/
function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
public
returns (uint256)
{
require(recipient != address(0x00), "stream to the zero address");
require(recipient != address(this), "stream to the contract itself");
require(recipient != msg.sender, "stream to the caller");
require(deposit > 0, "deposit is zero");
require(startTime >= block.timestamp, "start time before block.timestamp");
require(stopTime > startTime, "stop time before the start time");
CreateStreamLocalVars memory vars;
(vars.mathErr, vars.duration) = subUInt(stopTime, startTime);
/* `subUInt` can only return MathError.INTEGER_UNDERFLOW but we know `stopTime` is higher than `startTime`. */
assert(vars.mathErr == MathError.NO_ERROR);
/* Without this, the rate per second would be zero. */
require(deposit >= vars.duration, "deposit smaller than time delta");
/* This condition avoids dealing with remainders */
require(deposit % vars.duration == 0, "deposit not multiple of time delta");
(vars.mathErr, vars.ratePerSecond) = divUInt(deposit, vars.duration);
/* `divUInt` can only return MathError.DIVISION_BY_ZERO but we know `duration` is not zero. */
assert(vars.mathErr == MathError.NO_ERROR);
/* Create and store the stream object. */
uint256 streamId = nextStreamId;
streams[streamId] = Types.Stream({
remainingBalance: deposit,
deposit: deposit,
isEntity: true,
ratePerSecond: vars.ratePerSecond,
recipient: recipient,
sender: msg.sender,
startTime: startTime,
stopTime: stopTime,
tokenAddress: tokenAddress
});
/* Increment the next stream id. */
(vars.mathErr, nextStreamId) = addUInt(nextStreamId, uint256(1));
require(vars.mathErr == MathError.NO_ERROR, "next stream id calculation error");
require(<FILL_ME>)
emit CreateStream(streamId, msg.sender, recipient, deposit, tokenAddress, startTime, stopTime);
return streamId;
}
struct WithdrawFromStreamLocalVars {
MathError mathErr;
}
/**
* @notice Withdraws from the contract to the recipient's account.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if the amount exceeds the available balance.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to withdraw tokens from.
* @param amount The amount of tokens to withdraw.
* @return bool true=success, otherwise false.
*/
function withdrawFromStream(uint256 streamId, uint256 amount)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
}
/**
* @notice Cancels the stream and transfers the tokens back on a pro rata basis.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to cancel.
* @return bool true=success, otherwise false.
*/
function cancelStream(uint256 streamId)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
}
function setGov(address _gov) public {
}
function turnOnWithdrawals() public {
}
}
| IERC20(tokenAddress).transferFrom(msg.sender,address(this),deposit),"token transfer failure" | 376,171 | IERC20(tokenAddress).transferFrom(msg.sender,address(this),deposit) |
"token transfer failure" | // SPDX-License-Identifier: MIT
pragma solidity ^0.5.12;
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libs/IERC20.sol";
import "./libs/IERC1620.sol";
import "./libs/CarefulMath.sol";
import "./libs/Types.sol";
contract MeVesting is IERC1620, ReentrancyGuard, CarefulMath {
/*** Storage Properties ***/
/// @notice check to enable stream withdrawals
bool public withdrawable;
/// @notice address that can enable withdrawals
address public gov;
/**
* @notice Counter for new stream ids.
*/
uint256 public nextStreamId;
/**
* @notice The stream objects identifiable by their unsigned integer ids.
*/
mapping(uint256 => Types.Stream) private streams;
/*** Modifiers ***/
/**
* @dev Throws if the caller is not the sender of the recipient of the stream.
*/
modifier onlySenderOrRecipient(uint256 streamId) {
}
/**
* @dev Throws if the provided id does not point to a valid stream.
*/
modifier streamExists(uint256 streamId) {
}
/*** Contract Logic Starts Here */
constructor() public {
}
/*** View Functions ***/
/**
* @notice Returns the compounding stream with all its properties.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream to query.
* @return The stream object as an array of info.
*/
function getStream(uint256 streamId)
external
view
streamExists(streamId)
returns (
address sender,
address recipient,
uint256 deposit,
address tokenAddress,
uint256 startTime,
uint256 stopTime,
uint256 remainingBalance,
uint256 ratePerSecond
)
{
}
/**
* @notice Returns either the delta in seconds between `block.timestamp` and `startTime` or
* between `stopTime` and `startTime, whichever is smaller. If `block.timestamp` is before
* `startTime`, it returns 0.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the delta.
* @return The time delta in seconds.
*/
function deltaOf(uint256 streamId) public view streamExists(streamId) returns (uint256 delta) {
}
struct BalanceOfLocalVars {
MathError mathErr;
uint256 recipientBalance;
uint256 withdrawalAmount;
uint256 senderBalance;
}
/**
* @notice Returns the available funds for the given stream id and address.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the balance.
* @param who The address for which to query the balance.
* @return The total funds allocated to `who` as uint256.
*/
function balanceOf(uint256 streamId, address who) public view streamExists(streamId) returns (uint256 balance) {
}
/*** Public Effects & Interactions Functions ***/
struct CreateStreamLocalVars {
MathError mathErr;
uint256 duration;
uint256 ratePerSecond;
}
/**
* @notice Creates a new stream funded by `msg.sender` and paid towards `recipient`.
* @dev Throws if paused.
* Throws if the recipient is the zero address, the contract itself or the caller.
* Throws if the deposit is 0.
* Throws if the start time is before `block.timestamp`.
* Throws if the stop time is before the start time.
* Throws if the duration calculation has a math error.
* Throws if the deposit is smaller than the duration.
* Throws if the deposit is not a multiple of the duration.
* Throws if the rate calculation has a math error.
* Throws if the next stream id calculation has a math error.
* Throws if the contract is not allowed to transfer enough tokens.
* Throws if there is a token transfer failure.
* @param recipient The address towards which the money is streamed.
* @param deposit The amount of money to be streamed.
* @param tokenAddress The ERC20 token to use as streaming currency.
* @param startTime The unix timestamp for when the stream starts accumulating a pending stream balance.
* @param stopTime The unix timestamp for when the stream stops.
* @return The uint256 id of the newly created stream.
*/
function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
public
returns (uint256)
{
}
struct WithdrawFromStreamLocalVars {
MathError mathErr;
}
/**
* @notice Withdraws from the contract to the recipient's account.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if the amount exceeds the available balance.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to withdraw tokens from.
* @param amount The amount of tokens to withdraw.
* @return bool true=success, otherwise false.
*/
function withdrawFromStream(uint256 streamId, uint256 amount)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
require(withdrawable, "not withdrawable");
require(amount > 0, "amount is zero");
Types.Stream memory stream = streams[streamId];
WithdrawFromStreamLocalVars memory vars;
uint256 balance = balanceOf(streamId, stream.recipient);
require(balance >= amount, "amount exceeds the available balance");
(vars.mathErr, streams[streamId].remainingBalance) = subUInt(stream.remainingBalance, amount);
/**
* `subUInt` can only return MathError.INTEGER_UNDERFLOW but we know that `remainingBalance` is at least
* as big as `amount`.
*/
assert(vars.mathErr == MathError.NO_ERROR);
if (streams[streamId].remainingBalance == 0) delete streams[streamId];
require(<FILL_ME>)
emit WithdrawFromStream(streamId, stream.recipient, amount);
}
/**
* @notice Cancels the stream and transfers the tokens back on a pro rata basis.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to cancel.
* @return bool true=success, otherwise false.
*/
function cancelStream(uint256 streamId)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
}
function setGov(address _gov) public {
}
function turnOnWithdrawals() public {
}
}
| IERC20(stream.tokenAddress).transfer(stream.recipient,amount),"token transfer failure" | 376,171 | IERC20(stream.tokenAddress).transfer(stream.recipient,amount) |
"recipient token transfer failure" | // SPDX-License-Identifier: MIT
pragma solidity ^0.5.12;
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libs/IERC20.sol";
import "./libs/IERC1620.sol";
import "./libs/CarefulMath.sol";
import "./libs/Types.sol";
contract MeVesting is IERC1620, ReentrancyGuard, CarefulMath {
/*** Storage Properties ***/
/// @notice check to enable stream withdrawals
bool public withdrawable;
/// @notice address that can enable withdrawals
address public gov;
/**
* @notice Counter for new stream ids.
*/
uint256 public nextStreamId;
/**
* @notice The stream objects identifiable by their unsigned integer ids.
*/
mapping(uint256 => Types.Stream) private streams;
/*** Modifiers ***/
/**
* @dev Throws if the caller is not the sender of the recipient of the stream.
*/
modifier onlySenderOrRecipient(uint256 streamId) {
}
/**
* @dev Throws if the provided id does not point to a valid stream.
*/
modifier streamExists(uint256 streamId) {
}
/*** Contract Logic Starts Here */
constructor() public {
}
/*** View Functions ***/
/**
* @notice Returns the compounding stream with all its properties.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream to query.
* @return The stream object as an array of info.
*/
function getStream(uint256 streamId)
external
view
streamExists(streamId)
returns (
address sender,
address recipient,
uint256 deposit,
address tokenAddress,
uint256 startTime,
uint256 stopTime,
uint256 remainingBalance,
uint256 ratePerSecond
)
{
}
/**
* @notice Returns either the delta in seconds between `block.timestamp` and `startTime` or
* between `stopTime` and `startTime, whichever is smaller. If `block.timestamp` is before
* `startTime`, it returns 0.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the delta.
* @return The time delta in seconds.
*/
function deltaOf(uint256 streamId) public view streamExists(streamId) returns (uint256 delta) {
}
struct BalanceOfLocalVars {
MathError mathErr;
uint256 recipientBalance;
uint256 withdrawalAmount;
uint256 senderBalance;
}
/**
* @notice Returns the available funds for the given stream id and address.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the balance.
* @param who The address for which to query the balance.
* @return The total funds allocated to `who` as uint256.
*/
function balanceOf(uint256 streamId, address who) public view streamExists(streamId) returns (uint256 balance) {
}
/*** Public Effects & Interactions Functions ***/
struct CreateStreamLocalVars {
MathError mathErr;
uint256 duration;
uint256 ratePerSecond;
}
/**
* @notice Creates a new stream funded by `msg.sender` and paid towards `recipient`.
* @dev Throws if paused.
* Throws if the recipient is the zero address, the contract itself or the caller.
* Throws if the deposit is 0.
* Throws if the start time is before `block.timestamp`.
* Throws if the stop time is before the start time.
* Throws if the duration calculation has a math error.
* Throws if the deposit is smaller than the duration.
* Throws if the deposit is not a multiple of the duration.
* Throws if the rate calculation has a math error.
* Throws if the next stream id calculation has a math error.
* Throws if the contract is not allowed to transfer enough tokens.
* Throws if there is a token transfer failure.
* @param recipient The address towards which the money is streamed.
* @param deposit The amount of money to be streamed.
* @param tokenAddress The ERC20 token to use as streaming currency.
* @param startTime The unix timestamp for when the stream starts accumulating a pending stream balance.
* @param stopTime The unix timestamp for when the stream stops.
* @return The uint256 id of the newly created stream.
*/
function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
public
returns (uint256)
{
}
struct WithdrawFromStreamLocalVars {
MathError mathErr;
}
/**
* @notice Withdraws from the contract to the recipient's account.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if the amount exceeds the available balance.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to withdraw tokens from.
* @param amount The amount of tokens to withdraw.
* @return bool true=success, otherwise false.
*/
function withdrawFromStream(uint256 streamId, uint256 amount)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
}
/**
* @notice Cancels the stream and transfers the tokens back on a pro rata basis.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to cancel.
* @return bool true=success, otherwise false.
*/
function cancelStream(uint256 streamId)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
Types.Stream memory stream = streams[streamId];
uint256 senderBalance = balanceOf(streamId, stream.sender);
uint256 recipientBalance = balanceOf(streamId, stream.recipient);
delete streams[streamId];
IERC20 token = IERC20(stream.tokenAddress);
if (recipientBalance > 0)
require(<FILL_ME>)
if (senderBalance > 0) require(token.transfer(stream.sender, senderBalance), "sender token transfer failure");
emit CancelStream(streamId, stream.sender, stream.recipient, senderBalance, recipientBalance);
}
function setGov(address _gov) public {
}
function turnOnWithdrawals() public {
}
}
| token.transfer(stream.recipient,recipientBalance),"recipient token transfer failure" | 376,171 | token.transfer(stream.recipient,recipientBalance) |
"sender token transfer failure" | // SPDX-License-Identifier: MIT
pragma solidity ^0.5.12;
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libs/IERC20.sol";
import "./libs/IERC1620.sol";
import "./libs/CarefulMath.sol";
import "./libs/Types.sol";
contract MeVesting is IERC1620, ReentrancyGuard, CarefulMath {
/*** Storage Properties ***/
/// @notice check to enable stream withdrawals
bool public withdrawable;
/// @notice address that can enable withdrawals
address public gov;
/**
* @notice Counter for new stream ids.
*/
uint256 public nextStreamId;
/**
* @notice The stream objects identifiable by their unsigned integer ids.
*/
mapping(uint256 => Types.Stream) private streams;
/*** Modifiers ***/
/**
* @dev Throws if the caller is not the sender of the recipient of the stream.
*/
modifier onlySenderOrRecipient(uint256 streamId) {
}
/**
* @dev Throws if the provided id does not point to a valid stream.
*/
modifier streamExists(uint256 streamId) {
}
/*** Contract Logic Starts Here */
constructor() public {
}
/*** View Functions ***/
/**
* @notice Returns the compounding stream with all its properties.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream to query.
* @return The stream object as an array of info.
*/
function getStream(uint256 streamId)
external
view
streamExists(streamId)
returns (
address sender,
address recipient,
uint256 deposit,
address tokenAddress,
uint256 startTime,
uint256 stopTime,
uint256 remainingBalance,
uint256 ratePerSecond
)
{
}
/**
* @notice Returns either the delta in seconds between `block.timestamp` and `startTime` or
* between `stopTime` and `startTime, whichever is smaller. If `block.timestamp` is before
* `startTime`, it returns 0.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the delta.
* @return The time delta in seconds.
*/
function deltaOf(uint256 streamId) public view streamExists(streamId) returns (uint256 delta) {
}
struct BalanceOfLocalVars {
MathError mathErr;
uint256 recipientBalance;
uint256 withdrawalAmount;
uint256 senderBalance;
}
/**
* @notice Returns the available funds for the given stream id and address.
* @dev Throws if the id does not point to a valid stream.
* @param streamId The id of the stream for which to query the balance.
* @param who The address for which to query the balance.
* @return The total funds allocated to `who` as uint256.
*/
function balanceOf(uint256 streamId, address who) public view streamExists(streamId) returns (uint256 balance) {
}
/*** Public Effects & Interactions Functions ***/
struct CreateStreamLocalVars {
MathError mathErr;
uint256 duration;
uint256 ratePerSecond;
}
/**
* @notice Creates a new stream funded by `msg.sender` and paid towards `recipient`.
* @dev Throws if paused.
* Throws if the recipient is the zero address, the contract itself or the caller.
* Throws if the deposit is 0.
* Throws if the start time is before `block.timestamp`.
* Throws if the stop time is before the start time.
* Throws if the duration calculation has a math error.
* Throws if the deposit is smaller than the duration.
* Throws if the deposit is not a multiple of the duration.
* Throws if the rate calculation has a math error.
* Throws if the next stream id calculation has a math error.
* Throws if the contract is not allowed to transfer enough tokens.
* Throws if there is a token transfer failure.
* @param recipient The address towards which the money is streamed.
* @param deposit The amount of money to be streamed.
* @param tokenAddress The ERC20 token to use as streaming currency.
* @param startTime The unix timestamp for when the stream starts accumulating a pending stream balance.
* @param stopTime The unix timestamp for when the stream stops.
* @return The uint256 id of the newly created stream.
*/
function createStream(address recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime)
public
returns (uint256)
{
}
struct WithdrawFromStreamLocalVars {
MathError mathErr;
}
/**
* @notice Withdraws from the contract to the recipient's account.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if the amount exceeds the available balance.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to withdraw tokens from.
* @param amount The amount of tokens to withdraw.
* @return bool true=success, otherwise false.
*/
function withdrawFromStream(uint256 streamId, uint256 amount)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
}
/**
* @notice Cancels the stream and transfers the tokens back on a pro rata basis.
* @dev Throws if the id does not point to a valid stream.
* Throws if the caller is not the sender or the recipient of the stream.
* Throws if there is a token transfer failure.
* @param streamId The id of the stream to cancel.
* @return bool true=success, otherwise false.
*/
function cancelStream(uint256 streamId)
external
nonReentrant
streamExists(streamId)
onlySenderOrRecipient(streamId)
returns (bool)
{
Types.Stream memory stream = streams[streamId];
uint256 senderBalance = balanceOf(streamId, stream.sender);
uint256 recipientBalance = balanceOf(streamId, stream.recipient);
delete streams[streamId];
IERC20 token = IERC20(stream.tokenAddress);
if (recipientBalance > 0)
require(token.transfer(stream.recipient, recipientBalance), "recipient token transfer failure");
if (senderBalance > 0) require(<FILL_ME>)
emit CancelStream(streamId, stream.sender, stream.recipient, senderBalance, recipientBalance);
}
function setGov(address _gov) public {
}
function turnOnWithdrawals() public {
}
}
| token.transfer(stream.sender,senderBalance),"sender token transfer failure" | 376,171 | token.transfer(stream.sender,senderBalance) |
"Exceed max supply" | // SPDX-License-Identifier: UNLICENSED
/*
,------. ,--. ,--. ,------. ,--.
| .--. '| ,---. ,--,--.,--,--, ,-' '-. ,--,--. | .-. \ ,---. ,---. ,-| | ,---.
| '--' || .-. |' ,-. || \'-. .-'' ,-. | | | \ :| .-. || .-. |' .-. |( .-'
| | --' | | | |\ '-' || || | | | \ '-' | | '--' /' '-' '' '-' '\ `-' |.-' `)
`--' `--' `--' `--`--'`--''--' `--' `--`--' `-------' `---' `---' `---' `----'
*/
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract PhantaDoods is ERC721,Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
uint public maxInTx = 10;
bool public saleEnabled;
uint256 public price;
string public metadataBaseURL;
string public contractURI;
uint256 public constant FREE_SUPPLY = 2222;
uint256 public constant PAID_SUPPLY = 5555;
uint256 public constant MAX_SUPPLY = FREE_SUPPLY + PAID_SUPPLY;
bool public paidSupply;
constructor ()
ERC721("Phanta Doods", "PD") {
}
function setContractURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory baseURL) public onlyOwner {
}
function setMaxInTx(uint num) public onlyOwner {
}
function toggleSaleStatus() public onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function mintToAddress(address to) private onlyOwner {
}
function reserve(uint num) public onlyOwner {
}
function totalSupply() public view virtual returns (uint256) {
}
function mint(uint256 numOfTokens) public payable {
require(saleEnabled, "Sale must be active.");
require(<FILL_ME>)
require(numOfTokens > 0, "You must claim at least one.");
require(numOfTokens <= maxInTx, "Can't claim more than 10 in a tx.");
require((price * numOfTokens) <= msg.value, "Insufficient funds to claim.");
for(uint256 i=0; i< numOfTokens; i++) {
if((_tokenIdTracker.current() + 1 > FREE_SUPPLY) && !paidSupply) {
paidSupply = true;
price = 0.025 ether;
require((price * (numOfTokens - i)) <= msg.value, "Insufficient funds to claim.");
}
_safeMint(msg.sender, _tokenIdTracker.current() + 1);
_tokenIdTracker.increment();
}
}
}
| _tokenIdTracker.current()+numOfTokens<MAX_SUPPLY,"Exceed max supply" | 376,234 | _tokenIdTracker.current()+numOfTokens<MAX_SUPPLY |
"Insufficient funds to claim." | // SPDX-License-Identifier: UNLICENSED
/*
,------. ,--. ,--. ,------. ,--.
| .--. '| ,---. ,--,--.,--,--, ,-' '-. ,--,--. | .-. \ ,---. ,---. ,-| | ,---.
| '--' || .-. |' ,-. || \'-. .-'' ,-. | | | \ :| .-. || .-. |' .-. |( .-'
| | --' | | | |\ '-' || || | | | \ '-' | | '--' /' '-' '' '-' '\ `-' |.-' `)
`--' `--' `--' `--`--'`--''--' `--' `--`--' `-------' `---' `---' `---' `----'
*/
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract PhantaDoods is ERC721,Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
uint public maxInTx = 10;
bool public saleEnabled;
uint256 public price;
string public metadataBaseURL;
string public contractURI;
uint256 public constant FREE_SUPPLY = 2222;
uint256 public constant PAID_SUPPLY = 5555;
uint256 public constant MAX_SUPPLY = FREE_SUPPLY + PAID_SUPPLY;
bool public paidSupply;
constructor ()
ERC721("Phanta Doods", "PD") {
}
function setContractURI(string memory uri) public onlyOwner {
}
function setBaseURI(string memory baseURL) public onlyOwner {
}
function setMaxInTx(uint num) public onlyOwner {
}
function toggleSaleStatus() public onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function mintToAddress(address to) private onlyOwner {
}
function reserve(uint num) public onlyOwner {
}
function totalSupply() public view virtual returns (uint256) {
}
function mint(uint256 numOfTokens) public payable {
require(saleEnabled, "Sale must be active.");
require(_tokenIdTracker.current() + numOfTokens < MAX_SUPPLY, "Exceed max supply");
require(numOfTokens > 0, "You must claim at least one.");
require(numOfTokens <= maxInTx, "Can't claim more than 10 in a tx.");
require((price * numOfTokens) <= msg.value, "Insufficient funds to claim.");
for(uint256 i=0; i< numOfTokens; i++) {
if((_tokenIdTracker.current() + 1 > FREE_SUPPLY) && !paidSupply) {
paidSupply = true;
price = 0.025 ether;
require(<FILL_ME>)
}
_safeMint(msg.sender, _tokenIdTracker.current() + 1);
_tokenIdTracker.increment();
}
}
}
| (price*(numOfTokens-i))<=msg.value,"Insufficient funds to claim." | 376,234 | (price*(numOfTokens-i))<=msg.value |
null | pragma solidity ^ 0.5.17;
interface ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes20 data) external;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mult(uint256 x, uint256 y) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function divRound(uint256 x, uint256 y) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function approveAndCall(address spender, uint tokens, bytes calldata data) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function burn(uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ConTribute is ApproveAndCallFallBack{
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 2500e18;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
bool public onlyAmbassadors = true;
uint256 ACTIVATION_TIME = now+100 days;
modifier antiEarlyWhale(
uint256 _amountOfERC20,
address _customerAddress
)
{
}
modifier onlyTokenHolders {
}
modifier onlyDivis {
}
event onDistribute(
address indexed customerAddress,
uint256 price
);
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingERC20,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ERC20Earned,
uint timestamp
);
event onReinvestment(
address indexed customerAddress,
uint256 ERC20Reinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ERC20Withdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
string public name = "conTRIBUTE";
string public symbol = "CTRBT";
uint8 constant public decimals = 18;
uint256 public entryFee_ = 5;// 5%
uint256 public exitFee_ = 15; // 15%
uint256 public referralFee_ = 20; // 1% from the 5% fee
uint256 internal maintenanceFee_ = 0;//10; // 1% of the 10% fee
address internal maintenanceAddress;
uint256 constant internal magnitude = 2 ** 64;
mapping(address => uint256) public tokenBalanceLedger_;
mapping(address => uint256) public referralBalance_;
mapping(address => uint256) public totalReferralEarnings_;
mapping(address => int256) public payoutsTo_;
mapping(address => uint256) public invested_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
ERC20 erc20;
//testnet token 0x6A401A535a55f2BDAaE34622E4c3046E638c0d6e
//mainnet token 0x6b785a0322126826d8226d77e173d75DAfb84d11
constructor(address token,address extraAmbassador) public {
}
function activate() public{
require(<FILL_ME>)
ACTIVATION_TIME = now;
}
/*
allows playing without using approve
*/
function receiveApproval(address from, uint256 tokens, address token, bytes20 data) public{
}
function checkAndTransfer(
uint256 _amount
)
private
{
}
/*
transfer from custom address, only use with _buy
*/
function checkAndTransfer2(
uint256 _amount,
address _from
)
private
{
}
/*
Private buy function for use by approveandcall, to purchase tokens on behalf of the user when msg.sender is the token
*/
function _buy(
uint256 _amount,
address _sender,
address _referredBy
)
private
returns(uint256)
{
}
function buy(
uint256 _amount,
address _referredBy
)
public
returns(uint256)
{
}
function buyFor(
uint256 _amount,
address _customerAddress,
address _referredBy
)
public
returns(uint256)
{
}
function reinvest()
onlyDivis
public
{
}
function exit() external {
}
function withdraw()
onlyDivis
public
{
}
function sell(
uint256 _amountOfERC20s
)
onlyTokenHolders
public
{
}
function totalERC20Balance()
public
view
returns(uint256)
{
}
function totalSupply()
public
view
returns(uint256)
{
}
function myTokens()
public
view
returns(uint256)
{
}
function myDividends(
bool _includeReferralBonus
)
public
view
returns(uint256)
{
}
function balanceOf(
address _customerAddress
)
public
view
returns(uint256)
{
}
function dividendsOf(
address _customerAddress
)
public
view
returns(uint256)
{
}
function sellPrice()
public
view
returns(uint256)
{
}
function buyPrice()
public
view
returns(uint256)
{
}
function getInvested()
public
view
returns(uint256)
{
}
function totalReferralEarnings(
address _client
)
public
view
returns(uint256)
{
}
//event DebugTest3(uint256 amount,address sender,address this,uint approved,uint balance);
function donateTokens(uint256 todonate) public {
}
function purchaseTokens(
address _referredBy,
address _customerAddress,
uint256 _incomingERC20
)
internal
antiEarlyWhale(_incomingERC20, _customerAddress)
returns(uint256)
{
}
function multiData()
public
view
returns(
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| ambassadors_[msg.sender] | 376,243 | ambassadors_[msg.sender] |
"transfer must succeed" | pragma solidity ^ 0.5.17;
interface ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes20 data) external;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mult(uint256 x, uint256 y) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function divRound(uint256 x, uint256 y) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function approveAndCall(address spender, uint tokens, bytes calldata data) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function burn(uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ConTribute is ApproveAndCallFallBack{
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 2500e18;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
bool public onlyAmbassadors = true;
uint256 ACTIVATION_TIME = now+100 days;
modifier antiEarlyWhale(
uint256 _amountOfERC20,
address _customerAddress
)
{
}
modifier onlyTokenHolders {
}
modifier onlyDivis {
}
event onDistribute(
address indexed customerAddress,
uint256 price
);
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingERC20,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ERC20Earned,
uint timestamp
);
event onReinvestment(
address indexed customerAddress,
uint256 ERC20Reinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ERC20Withdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
string public name = "conTRIBUTE";
string public symbol = "CTRBT";
uint8 constant public decimals = 18;
uint256 public entryFee_ = 5;// 5%
uint256 public exitFee_ = 15; // 15%
uint256 public referralFee_ = 20; // 1% from the 5% fee
uint256 internal maintenanceFee_ = 0;//10; // 1% of the 10% fee
address internal maintenanceAddress;
uint256 constant internal magnitude = 2 ** 64;
mapping(address => uint256) public tokenBalanceLedger_;
mapping(address => uint256) public referralBalance_;
mapping(address => uint256) public totalReferralEarnings_;
mapping(address => int256) public payoutsTo_;
mapping(address => uint256) public invested_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
ERC20 erc20;
//testnet token 0x6A401A535a55f2BDAaE34622E4c3046E638c0d6e
//mainnet token 0x6b785a0322126826d8226d77e173d75DAfb84d11
constructor(address token,address extraAmbassador) public {
}
function activate() public{
}
/*
allows playing without using approve
*/
function receiveApproval(address from, uint256 tokens, address token, bytes20 data) public{
}
function checkAndTransfer(
uint256 _amount
)
private
{
}
/*
transfer from custom address, only use with _buy
*/
function checkAndTransfer2(
uint256 _amount,
address _from
)
private
{
require(<FILL_ME>)
}
/*
Private buy function for use by approveandcall, to purchase tokens on behalf of the user when msg.sender is the token
*/
function _buy(
uint256 _amount,
address _sender,
address _referredBy
)
private
returns(uint256)
{
}
function buy(
uint256 _amount,
address _referredBy
)
public
returns(uint256)
{
}
function buyFor(
uint256 _amount,
address _customerAddress,
address _referredBy
)
public
returns(uint256)
{
}
function reinvest()
onlyDivis
public
{
}
function exit() external {
}
function withdraw()
onlyDivis
public
{
}
function sell(
uint256 _amountOfERC20s
)
onlyTokenHolders
public
{
}
function totalERC20Balance()
public
view
returns(uint256)
{
}
function totalSupply()
public
view
returns(uint256)
{
}
function myTokens()
public
view
returns(uint256)
{
}
function myDividends(
bool _includeReferralBonus
)
public
view
returns(uint256)
{
}
function balanceOf(
address _customerAddress
)
public
view
returns(uint256)
{
}
function dividendsOf(
address _customerAddress
)
public
view
returns(uint256)
{
}
function sellPrice()
public
view
returns(uint256)
{
}
function buyPrice()
public
view
returns(uint256)
{
}
function getInvested()
public
view
returns(uint256)
{
}
function totalReferralEarnings(
address _client
)
public
view
returns(uint256)
{
}
//event DebugTest3(uint256 amount,address sender,address this,uint approved,uint balance);
function donateTokens(uint256 todonate) public {
}
function purchaseTokens(
address _referredBy,
address _customerAddress,
uint256 _incomingERC20
)
internal
antiEarlyWhale(_incomingERC20, _customerAddress)
returns(uint256)
{
}
function multiData()
public
view
returns(
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| erc20.transferFrom(_from,address(this),_amount)==true,"transfer must succeed" | 376,243 | erc20.transferFrom(_from,address(this),_amount)==true |
'Maximum NFT Limit Reached' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(preSaleActive == true , "Pre-Sale is not currently open");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdressPresale , 'Invalid Mint Amount');
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxPublicBulbs , 'Not Enough Mandelbulbs Left');
require(msg.value >= _mintAmount * presaleMintPrice, 'Incorrect Amount of Ether Sent');
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_MerkleProof , whitelistMerkleRoot , leaf) , 'Sorry, it appears you are not on the whitelist');
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| addressMintedAmounts[msg.sender]+_mintAmount<=maxNftPerAdressPresale,'Maximum NFT Limit Reached' | 376,260 | addressMintedAmounts[msg.sender]+_mintAmount<=maxNftPerAdressPresale |
'Not Enough Mandelbulbs Left' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(preSaleActive == true , "Pre-Sale is not currently open");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdressPresale , 'Invalid Mint Amount');
require(addressMintedAmounts[msg.sender] + _mintAmount <= maxNftPerAdressPresale , 'Maximum NFT Limit Reached');
require(<FILL_ME>)
require(msg.value >= _mintAmount * presaleMintPrice, 'Incorrect Amount of Ether Sent');
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_MerkleProof , whitelistMerkleRoot , leaf) , 'Sorry, it appears you are not on the whitelist');
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| totalSupply()+_mintAmount<=maxPublicBulbs,'Not Enough Mandelbulbs Left' | 376,260 | totalSupply()+_mintAmount<=maxPublicBulbs |
'Sorry, it appears you are not on the whitelist' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(preSaleActive == true , "Pre-Sale is not currently open");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdressPresale , 'Invalid Mint Amount');
require(addressMintedAmounts[msg.sender] + _mintAmount <= maxNftPerAdressPresale , 'Maximum NFT Limit Reached');
require(totalSupply() + _mintAmount <= maxPublicBulbs , 'Not Enough Mandelbulbs Left');
require(msg.value >= _mintAmount * presaleMintPrice, 'Incorrect Amount of Ether Sent');
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| MerkleProof.verify(_MerkleProof,whitelistMerkleRoot,leaf),'Sorry, it appears you are not on the whitelist' | 376,260 | MerkleProof.verify(_MerkleProof,whitelistMerkleRoot,leaf) |
"You already claimed" | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(<FILL_ME>)
require(preSaleActive == true , "Pre-Sale is not currently open");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdressPresale , 'Invalid Mint Amount');
require(addressMintedAmounts[msg.sender] + _mintAmount <= maxNftPerAdressPresale , 'Maximum NFT Limit Reached');
require(msg.value >= ((_mintAmount-1) * presaleMintPrice), 'Incorrect Amount of Ether Sent');
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_Proof , OneDMerkleRoot , leaf) , 'Sorry, it appears you are not on the whitelist');
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
addressClaimed[msg.sender] = true;
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| addressClaimed[msg.sender]==false,"You already claimed" | 376,260 | addressClaimed[msg.sender]==false |
'Incorrect Amount of Ether Sent' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(addressClaimed[msg.sender] == false , "You already claimed");
require(preSaleActive == true , "Pre-Sale is not currently open");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdressPresale , 'Invalid Mint Amount');
require(addressMintedAmounts[msg.sender] + _mintAmount <= maxNftPerAdressPresale , 'Maximum NFT Limit Reached');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_Proof , OneDMerkleRoot , leaf) , 'Sorry, it appears you are not on the whitelist');
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
addressClaimed[msg.sender] = true;
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| msg.value>=((_mintAmount-1)*presaleMintPrice),'Incorrect Amount of Ether Sent' | 376,260 | msg.value>=((_mintAmount-1)*presaleMintPrice) |
'Sorry, it appears you are not on the whitelist' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(addressClaimed[msg.sender] == false , "You already claimed");
require(preSaleActive == true , "Pre-Sale is not currently open");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdressPresale , 'Invalid Mint Amount');
require(addressMintedAmounts[msg.sender] + _mintAmount <= maxNftPerAdressPresale , 'Maximum NFT Limit Reached');
require(msg.value >= ((_mintAmount-1) * presaleMintPrice), 'Incorrect Amount of Ether Sent');
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
addressClaimed[msg.sender] = true;
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| MerkleProof.verify(_Proof,OneDMerkleRoot,leaf),'Sorry, it appears you are not on the whitelist' | 376,260 | MerkleProof.verify(_Proof,OneDMerkleRoot,leaf) |
'Incorrect Amount of Ether Sent' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(publicSaleActive == true , "Public Sale is not currently open!");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdress , 'Invalid Mint Amount');
require(totalSupply() + _mintAmount <= maxPublicBulbs , 'Not Enough Mandelbulbs Left');
require(<FILL_ME>)
require(addressMintedAmounts[msg.sender] + _mintAmount <= maxNftPerAdress , 'Maximum NFT Limit Reached');
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| _mintAmount*publicMintPrice>=msg.value,'Incorrect Amount of Ether Sent' | 376,260 | _mintAmount*publicMintPrice>=msg.value |
'Maximum NFT Limit Reached' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
require(!paused , 'The Contract is not Currently Open for Minting');
require(publicSaleActive == true , "Public Sale is not currently open!");
require(_mintAmount != 0 && _mintAmount <= maxNftPerAdress , 'Invalid Mint Amount');
require(totalSupply() + _mintAmount <= maxPublicBulbs , 'Not Enough Mandelbulbs Left');
require(_mintAmount * publicMintPrice >= msg.value, 'Incorrect Amount of Ether Sent');
require(<FILL_ME>)
mint(_mintAmount);
addressMintedAmounts[msg.sender] += _mintAmount;
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| addressMintedAmounts[msg.sender]+_mintAmount<=maxNftPerAdress,'Maximum NFT Limit Reached' | 376,260 | addressMintedAmounts[msg.sender]+_mintAmount<=maxNftPerAdress |
'No NFTS Left' | pragma solidity >=0.7.0 <0.9.0;
contract MandelbulbSetCollection is Ownable , ERC721A , ReentrancyGuard {
using Strings for uint256;
//Token Data
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
mapping(address => uint256) public presaleMintedAmounts;
mapping(address => uint256) private founderMintedAmounts;
mapping(address => uint256) public addressMintedAmounts;
mapping(address => bool) public addressClaimed;
uint256 _currentFounderSupply = 0;
//Sale Data
bool public paused = true;
bool public revealed = false;
bool public preSaleActive = false;
bool public publicSaleActive = false;
bytes32 private whitelistMerkleRoot = 0;
bytes32 private OneDMerkleRoot = 0;
uint256 private constant maxBulbs = 5000;
uint256 private constant founderReserves = 25;
uint256 private constant maxPublicBulbs = maxBulbs - founderReserves;
uint256 private constant publicMintPrice = 0.04 ether;
uint256 private constant maxNftPerAdress = 10;
uint256 private constant presaleMintPrice = 0.03 ether;
uint256 private constant maxNftPerAdressPresale = 5;
constructor (
string memory _name ,
string memory _symbol ,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function WhitelistedMint(uint256 _mintAmount , bytes32[] calldata _MerkleProof) external payable nonReentrant {
}
function OneDMint(uint256 _mintAmount , bytes32[] calldata _Proof) external payable nonReentrant {
}
function PublicMint(uint256 _mintAmount) external payable nonReentrant {
}
function FounderMint(uint256 _mintAmount) external payable nonReentrant onlyOwner {
require(<FILL_ME>)
require(_mintAmount != 0 && _mintAmount <= founderReserves , 'Invalid Mint Amount');
mint(_mintAmount);
_currentFounderSupply += _mintAmount;
}
function mint(uint256 _mintAmount) internal {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function reveal() public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function PreSale(bool _state) public onlyOwner {
}
function PublicSale(bool _state) public onlyOwner {
}
function setMerkleRoots(bytes32 _WLroot , bytes32 _oneDRoot ) internal {
}
function openPreSale(bytes32 _oneDRoot , bytes32 _WLroot) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function amountMinted() public view returns (uint256) {
}
}
| _currentFounderSupply+_mintAmount<=founderReserves,'No NFTS Left' | 376,260 | _currentFounderSupply+_mintAmount<=founderReserves |
"You are not the bounty publisher" | pragma solidity ^0.6.10;
//Contract deployed on ropsten: 0xb4b333123caf6b29da37e7973aceed4e82d8206b
//Test Cash contract: 0x0f54093364b396461AAdf85C015Db597AAb56203
//Mainnet: 0x73aa31Cd548AC14713F778f454348d90564e2dE1
//Devcash: 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a
abstract contract ERC20{
function balanceOf(address who) public virtual view returns (uint256);
function transfer(address to, uint256 value) public virtual returns (bool);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
}
abstract contract ERC20Approve {
function approve(address spender, uint256 value) public virtual returns (bool);
}
contract bountyChest{
address payable creator;
constructor () public {
}
receive() external payable{
}
function transfer(address payable to, uint amount) public payable{
}
}
contract ubountyCreator{
string public version = "ubounties-v0.8b";
event created(uint uBountyIndex,uint bountiesAvailable, uint tokenAmount, uint weiAmount); //add a
event submitted(uint uBountyIndex, uint submissionIndex);
event revised(uint uBountyIndex,uint submissionIndex, uint revisionIndex);
event approved(uint uBountyIndex, uint submissionIndex, string feedback);
event rejected(uint uBountyIndex, uint submissionIndex, string feedback);
event revisionRequested(uint uBountyIndex, uint submissionIndex, string feedback);
event rewarded(uint uBountyIndex, uint submissionIndex, address Hunter, uint tokenAmount,uint weiAmount);
event reclaimed(uint uBountyIndex, uint tokenAmount, uint weiAmount);
event completed(uint uBountyIndex);
event feeChange(uint oldFee, uint newFee);
event waiverChange(uint oldWaiver, uint newWaiver);
address public devcash = 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a;
address public admin;
address payable public collector = 0xB1F445F64CDDe81d58c26ab1C340FE2a82F55A4C;
uint public fee;
uint public waiver;
struct submission{
uint32 submitterIndex;
string submissionString;
bool approved;
mapping(uint=>string) revisions;
uint8 numRevisions;
}
struct ubounty{
uint8 available; //rename to avaiable
uint8 numSubmissions;
uint32 hunterIndex;
uint32 creatorIndex;
uint32 bountyChestIndex;
uint48 deadline;
string name;
string description;
mapping(uint => submission) submissions;
}
mapping(uint => ubounty) public ubounties;
uint public numUbounties;
function getSubmission(uint ubountyIndex, uint submissionIndex) public view returns(string memory,address, bool,uint) {
}
function getRevision(uint ubountyIndex,uint submissionIndex, uint revisionIndex) public view returns (string memory){
}
mapping(address=>uint32) bountyChests; //mapping bounty chest address to bounty chest index
address payable[] public bCList; //list of bounty chest addresses
uint[] public freeBC; // list of unused bounty chests
function numBC() public view returns(uint){
}
mapping(address => uint32) public users;
address payable[] public userList;
function numUsers() public view returns(uint){
}
constructor() public {
}
//rename numleft to numavailable
function postOpenBounty(
string memory name,
string memory description,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function postPersonalBounty(
string memory name,
string memory description,
address payable hunter,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function awardOpenBounty(uint ubountyIndex, address payable hunter) public{
require(<FILL_ME>)
require(ubounties[ubountyIndex].available>0,"This bounty is inactive");
require(ubounties[ubountyIndex].hunterIndex==0,"Only works for Open Bounties");
uint rewardAmount = bountyAmount(ubountyIndex)/ubounties[ubountyIndex].available;
uint weiAmount = weiBountyAmount(ubountyIndex)/ubounties[ubountyIndex].available;
ubounties[ubountyIndex].available--;
ERC20(devcash).transferFrom(bCList[ubounties[ubountyIndex].bountyChestIndex],hunter,rewardAmount);
transferEth(ubountyIndex,hunter,weiAmount);
if(ubounties[ubountyIndex].available==0){
freeBC.push(ubounties[ubountyIndex].bountyChestIndex);
emit completed(ubountyIndex);
}
emit rewarded(ubountyIndex,0,hunter,rewardAmount,weiAmount);
}
function awardPersonalBounty(string memory name, string memory description, address payable hunter, uint tokenAmount) public payable {
}
function getFee(address Poster) public view returns(uint _fee) {
}
function addUser(address payable user) public {
}
function getBountyChest() internal returns(address payable bCAddress){
}
function setUbounty(
uint32 creatorIndex,
uint32 hunterIndex,
uint8 available,
string memory name,
string memory description,
uint32 bountyChestIndex,
uint48 deadline
) internal {
}
function submit(uint ubountyIndex, string memory submissionString) public {
}
function revise(uint ubountyIndex, uint32 submissionIndex, string memory revisionString) public {
}
function approve(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function reject(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function requestRevision(uint ubountyIndex,uint submissionIndex,string memory feedback) public {
}
function reward(uint ubountyIndex, uint submissionIndex, address payable hunter) internal {
}
function contribute(uint ubountyIndex, uint amount) public{
}
function contributeWei(uint ubountyIndex) public payable{
}
function reclaim(uint ubountyIndex) public {
}
function reclaimable(uint ubountyIndex) public view returns(bool){
}
function reclaimableNow(uint ubountyIndex) public view returns(bool){
}
function transferFrom(address from, address to, uint amount) internal {
}
function transferEth(uint ubountyIndex, address payable to, uint amount) internal {
}
function bountyAmount(uint ubountyIndex) public view returns(uint){
}
function weiBountyAmount(uint ubountyIndex) public view returns(uint){
}
function createBountyChest() public {
}
function setFee(uint _fee) public {
}
function setWaiver(uint _waiver) public {
}
function satisfiesWaiver(address poster) public view returns(bool){
}
}
| users[msg.sender]==ubounties[ubountyIndex].creatorIndex,"You are not the bounty publisher" | 376,327 | users[msg.sender]==ubounties[ubountyIndex].creatorIndex |
"This bounty is inactive" | pragma solidity ^0.6.10;
//Contract deployed on ropsten: 0xb4b333123caf6b29da37e7973aceed4e82d8206b
//Test Cash contract: 0x0f54093364b396461AAdf85C015Db597AAb56203
//Mainnet: 0x73aa31Cd548AC14713F778f454348d90564e2dE1
//Devcash: 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a
abstract contract ERC20{
function balanceOf(address who) public virtual view returns (uint256);
function transfer(address to, uint256 value) public virtual returns (bool);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
}
abstract contract ERC20Approve {
function approve(address spender, uint256 value) public virtual returns (bool);
}
contract bountyChest{
address payable creator;
constructor () public {
}
receive() external payable{
}
function transfer(address payable to, uint amount) public payable{
}
}
contract ubountyCreator{
string public version = "ubounties-v0.8b";
event created(uint uBountyIndex,uint bountiesAvailable, uint tokenAmount, uint weiAmount); //add a
event submitted(uint uBountyIndex, uint submissionIndex);
event revised(uint uBountyIndex,uint submissionIndex, uint revisionIndex);
event approved(uint uBountyIndex, uint submissionIndex, string feedback);
event rejected(uint uBountyIndex, uint submissionIndex, string feedback);
event revisionRequested(uint uBountyIndex, uint submissionIndex, string feedback);
event rewarded(uint uBountyIndex, uint submissionIndex, address Hunter, uint tokenAmount,uint weiAmount);
event reclaimed(uint uBountyIndex, uint tokenAmount, uint weiAmount);
event completed(uint uBountyIndex);
event feeChange(uint oldFee, uint newFee);
event waiverChange(uint oldWaiver, uint newWaiver);
address public devcash = 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a;
address public admin;
address payable public collector = 0xB1F445F64CDDe81d58c26ab1C340FE2a82F55A4C;
uint public fee;
uint public waiver;
struct submission{
uint32 submitterIndex;
string submissionString;
bool approved;
mapping(uint=>string) revisions;
uint8 numRevisions;
}
struct ubounty{
uint8 available; //rename to avaiable
uint8 numSubmissions;
uint32 hunterIndex;
uint32 creatorIndex;
uint32 bountyChestIndex;
uint48 deadline;
string name;
string description;
mapping(uint => submission) submissions;
}
mapping(uint => ubounty) public ubounties;
uint public numUbounties;
function getSubmission(uint ubountyIndex, uint submissionIndex) public view returns(string memory,address, bool,uint) {
}
function getRevision(uint ubountyIndex,uint submissionIndex, uint revisionIndex) public view returns (string memory){
}
mapping(address=>uint32) bountyChests; //mapping bounty chest address to bounty chest index
address payable[] public bCList; //list of bounty chest addresses
uint[] public freeBC; // list of unused bounty chests
function numBC() public view returns(uint){
}
mapping(address => uint32) public users;
address payable[] public userList;
function numUsers() public view returns(uint){
}
constructor() public {
}
//rename numleft to numavailable
function postOpenBounty(
string memory name,
string memory description,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function postPersonalBounty(
string memory name,
string memory description,
address payable hunter,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function awardOpenBounty(uint ubountyIndex, address payable hunter) public{
require(users[msg.sender]==ubounties[ubountyIndex].creatorIndex,"You are not the bounty publisher");
require(<FILL_ME>)
require(ubounties[ubountyIndex].hunterIndex==0,"Only works for Open Bounties");
uint rewardAmount = bountyAmount(ubountyIndex)/ubounties[ubountyIndex].available;
uint weiAmount = weiBountyAmount(ubountyIndex)/ubounties[ubountyIndex].available;
ubounties[ubountyIndex].available--;
ERC20(devcash).transferFrom(bCList[ubounties[ubountyIndex].bountyChestIndex],hunter,rewardAmount);
transferEth(ubountyIndex,hunter,weiAmount);
if(ubounties[ubountyIndex].available==0){
freeBC.push(ubounties[ubountyIndex].bountyChestIndex);
emit completed(ubountyIndex);
}
emit rewarded(ubountyIndex,0,hunter,rewardAmount,weiAmount);
}
function awardPersonalBounty(string memory name, string memory description, address payable hunter, uint tokenAmount) public payable {
}
function getFee(address Poster) public view returns(uint _fee) {
}
function addUser(address payable user) public {
}
function getBountyChest() internal returns(address payable bCAddress){
}
function setUbounty(
uint32 creatorIndex,
uint32 hunterIndex,
uint8 available,
string memory name,
string memory description,
uint32 bountyChestIndex,
uint48 deadline
) internal {
}
function submit(uint ubountyIndex, string memory submissionString) public {
}
function revise(uint ubountyIndex, uint32 submissionIndex, string memory revisionString) public {
}
function approve(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function reject(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function requestRevision(uint ubountyIndex,uint submissionIndex,string memory feedback) public {
}
function reward(uint ubountyIndex, uint submissionIndex, address payable hunter) internal {
}
function contribute(uint ubountyIndex, uint amount) public{
}
function contributeWei(uint ubountyIndex) public payable{
}
function reclaim(uint ubountyIndex) public {
}
function reclaimable(uint ubountyIndex) public view returns(bool){
}
function reclaimableNow(uint ubountyIndex) public view returns(bool){
}
function transferFrom(address from, address to, uint amount) internal {
}
function transferEth(uint ubountyIndex, address payable to, uint amount) internal {
}
function bountyAmount(uint ubountyIndex) public view returns(uint){
}
function weiBountyAmount(uint ubountyIndex) public view returns(uint){
}
function createBountyChest() public {
}
function setFee(uint _fee) public {
}
function setWaiver(uint _waiver) public {
}
function satisfiesWaiver(address poster) public view returns(bool){
}
}
| ubounties[ubountyIndex].available>0,"This bounty is inactive" | 376,327 | ubounties[ubountyIndex].available>0 |
"Only works for Open Bounties" | pragma solidity ^0.6.10;
//Contract deployed on ropsten: 0xb4b333123caf6b29da37e7973aceed4e82d8206b
//Test Cash contract: 0x0f54093364b396461AAdf85C015Db597AAb56203
//Mainnet: 0x73aa31Cd548AC14713F778f454348d90564e2dE1
//Devcash: 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a
abstract contract ERC20{
function balanceOf(address who) public virtual view returns (uint256);
function transfer(address to, uint256 value) public virtual returns (bool);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
}
abstract contract ERC20Approve {
function approve(address spender, uint256 value) public virtual returns (bool);
}
contract bountyChest{
address payable creator;
constructor () public {
}
receive() external payable{
}
function transfer(address payable to, uint amount) public payable{
}
}
contract ubountyCreator{
string public version = "ubounties-v0.8b";
event created(uint uBountyIndex,uint bountiesAvailable, uint tokenAmount, uint weiAmount); //add a
event submitted(uint uBountyIndex, uint submissionIndex);
event revised(uint uBountyIndex,uint submissionIndex, uint revisionIndex);
event approved(uint uBountyIndex, uint submissionIndex, string feedback);
event rejected(uint uBountyIndex, uint submissionIndex, string feedback);
event revisionRequested(uint uBountyIndex, uint submissionIndex, string feedback);
event rewarded(uint uBountyIndex, uint submissionIndex, address Hunter, uint tokenAmount,uint weiAmount);
event reclaimed(uint uBountyIndex, uint tokenAmount, uint weiAmount);
event completed(uint uBountyIndex);
event feeChange(uint oldFee, uint newFee);
event waiverChange(uint oldWaiver, uint newWaiver);
address public devcash = 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a;
address public admin;
address payable public collector = 0xB1F445F64CDDe81d58c26ab1C340FE2a82F55A4C;
uint public fee;
uint public waiver;
struct submission{
uint32 submitterIndex;
string submissionString;
bool approved;
mapping(uint=>string) revisions;
uint8 numRevisions;
}
struct ubounty{
uint8 available; //rename to avaiable
uint8 numSubmissions;
uint32 hunterIndex;
uint32 creatorIndex;
uint32 bountyChestIndex;
uint48 deadline;
string name;
string description;
mapping(uint => submission) submissions;
}
mapping(uint => ubounty) public ubounties;
uint public numUbounties;
function getSubmission(uint ubountyIndex, uint submissionIndex) public view returns(string memory,address, bool,uint) {
}
function getRevision(uint ubountyIndex,uint submissionIndex, uint revisionIndex) public view returns (string memory){
}
mapping(address=>uint32) bountyChests; //mapping bounty chest address to bounty chest index
address payable[] public bCList; //list of bounty chest addresses
uint[] public freeBC; // list of unused bounty chests
function numBC() public view returns(uint){
}
mapping(address => uint32) public users;
address payable[] public userList;
function numUsers() public view returns(uint){
}
constructor() public {
}
//rename numleft to numavailable
function postOpenBounty(
string memory name,
string memory description,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function postPersonalBounty(
string memory name,
string memory description,
address payable hunter,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function awardOpenBounty(uint ubountyIndex, address payable hunter) public{
require(users[msg.sender]==ubounties[ubountyIndex].creatorIndex,"You are not the bounty publisher");
require(ubounties[ubountyIndex].available>0,"This bounty is inactive");
require(<FILL_ME>)
uint rewardAmount = bountyAmount(ubountyIndex)/ubounties[ubountyIndex].available;
uint weiAmount = weiBountyAmount(ubountyIndex)/ubounties[ubountyIndex].available;
ubounties[ubountyIndex].available--;
ERC20(devcash).transferFrom(bCList[ubounties[ubountyIndex].bountyChestIndex],hunter,rewardAmount);
transferEth(ubountyIndex,hunter,weiAmount);
if(ubounties[ubountyIndex].available==0){
freeBC.push(ubounties[ubountyIndex].bountyChestIndex);
emit completed(ubountyIndex);
}
emit rewarded(ubountyIndex,0,hunter,rewardAmount,weiAmount);
}
function awardPersonalBounty(string memory name, string memory description, address payable hunter, uint tokenAmount) public payable {
}
function getFee(address Poster) public view returns(uint _fee) {
}
function addUser(address payable user) public {
}
function getBountyChest() internal returns(address payable bCAddress){
}
function setUbounty(
uint32 creatorIndex,
uint32 hunterIndex,
uint8 available,
string memory name,
string memory description,
uint32 bountyChestIndex,
uint48 deadline
) internal {
}
function submit(uint ubountyIndex, string memory submissionString) public {
}
function revise(uint ubountyIndex, uint32 submissionIndex, string memory revisionString) public {
}
function approve(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function reject(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function requestRevision(uint ubountyIndex,uint submissionIndex,string memory feedback) public {
}
function reward(uint ubountyIndex, uint submissionIndex, address payable hunter) internal {
}
function contribute(uint ubountyIndex, uint amount) public{
}
function contributeWei(uint ubountyIndex) public payable{
}
function reclaim(uint ubountyIndex) public {
}
function reclaimable(uint ubountyIndex) public view returns(bool){
}
function reclaimableNow(uint ubountyIndex) public view returns(bool){
}
function transferFrom(address from, address to, uint amount) internal {
}
function transferEth(uint ubountyIndex, address payable to, uint amount) internal {
}
function bountyAmount(uint ubountyIndex) public view returns(uint){
}
function weiBountyAmount(uint ubountyIndex) public view returns(uint){
}
function createBountyChest() public {
}
function setFee(uint _fee) public {
}
function setWaiver(uint _waiver) public {
}
function satisfiesWaiver(address poster) public view returns(bool){
}
}
| ubounties[ubountyIndex].hunterIndex==0,"Only works for Open Bounties" | 376,327 | ubounties[ubountyIndex].hunterIndex==0 |
"You are not the bounty hunter" | pragma solidity ^0.6.10;
//Contract deployed on ropsten: 0xb4b333123caf6b29da37e7973aceed4e82d8206b
//Test Cash contract: 0x0f54093364b396461AAdf85C015Db597AAb56203
//Mainnet: 0x73aa31Cd548AC14713F778f454348d90564e2dE1
//Devcash: 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a
abstract contract ERC20{
function balanceOf(address who) public virtual view returns (uint256);
function transfer(address to, uint256 value) public virtual returns (bool);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
}
abstract contract ERC20Approve {
function approve(address spender, uint256 value) public virtual returns (bool);
}
contract bountyChest{
address payable creator;
constructor () public {
}
receive() external payable{
}
function transfer(address payable to, uint amount) public payable{
}
}
contract ubountyCreator{
string public version = "ubounties-v0.8b";
event created(uint uBountyIndex,uint bountiesAvailable, uint tokenAmount, uint weiAmount); //add a
event submitted(uint uBountyIndex, uint submissionIndex);
event revised(uint uBountyIndex,uint submissionIndex, uint revisionIndex);
event approved(uint uBountyIndex, uint submissionIndex, string feedback);
event rejected(uint uBountyIndex, uint submissionIndex, string feedback);
event revisionRequested(uint uBountyIndex, uint submissionIndex, string feedback);
event rewarded(uint uBountyIndex, uint submissionIndex, address Hunter, uint tokenAmount,uint weiAmount);
event reclaimed(uint uBountyIndex, uint tokenAmount, uint weiAmount);
event completed(uint uBountyIndex);
event feeChange(uint oldFee, uint newFee);
event waiverChange(uint oldWaiver, uint newWaiver);
address public devcash = 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a;
address public admin;
address payable public collector = 0xB1F445F64CDDe81d58c26ab1C340FE2a82F55A4C;
uint public fee;
uint public waiver;
struct submission{
uint32 submitterIndex;
string submissionString;
bool approved;
mapping(uint=>string) revisions;
uint8 numRevisions;
}
struct ubounty{
uint8 available; //rename to avaiable
uint8 numSubmissions;
uint32 hunterIndex;
uint32 creatorIndex;
uint32 bountyChestIndex;
uint48 deadline;
string name;
string description;
mapping(uint => submission) submissions;
}
mapping(uint => ubounty) public ubounties;
uint public numUbounties;
function getSubmission(uint ubountyIndex, uint submissionIndex) public view returns(string memory,address, bool,uint) {
}
function getRevision(uint ubountyIndex,uint submissionIndex, uint revisionIndex) public view returns (string memory){
}
mapping(address=>uint32) bountyChests; //mapping bounty chest address to bounty chest index
address payable[] public bCList; //list of bounty chest addresses
uint[] public freeBC; // list of unused bounty chests
function numBC() public view returns(uint){
}
mapping(address => uint32) public users;
address payable[] public userList;
function numUsers() public view returns(uint){
}
constructor() public {
}
//rename numleft to numavailable
function postOpenBounty(
string memory name,
string memory description,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function postPersonalBounty(
string memory name,
string memory description,
address payable hunter,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function awardOpenBounty(uint ubountyIndex, address payable hunter) public{
}
function awardPersonalBounty(string memory name, string memory description, address payable hunter, uint tokenAmount) public payable {
}
function getFee(address Poster) public view returns(uint _fee) {
}
function addUser(address payable user) public {
}
function getBountyChest() internal returns(address payable bCAddress){
}
function setUbounty(
uint32 creatorIndex,
uint32 hunterIndex,
uint8 available,
string memory name,
string memory description,
uint32 bountyChestIndex,
uint48 deadline
) internal {
}
function submit(uint ubountyIndex, string memory submissionString) public {
require(<FILL_ME>)
require(now<=ubounties[ubountyIndex].deadline,"The bounty deadline has passed");
require(ubounties[ubountyIndex].available>0,"This bounty is inactive"); //make sure available is more than 0
if(users[msg.sender]==0){
users[msg.sender] = uint32(userList.length);
userList.push(msg.sender);
}
ubounties[ubountyIndex].submissions[ubounties[ubountyIndex].numSubmissions].submissionString = submissionString;
ubounties[ubountyIndex].submissions[ubounties[ubountyIndex].numSubmissions].submitterIndex = users[msg.sender];
emit submitted(ubountyIndex,ubounties[ubountyIndex].numSubmissions++);
}
function revise(uint ubountyIndex, uint32 submissionIndex, string memory revisionString) public {
}
function approve(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function reject(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function requestRevision(uint ubountyIndex,uint submissionIndex,string memory feedback) public {
}
function reward(uint ubountyIndex, uint submissionIndex, address payable hunter) internal {
}
function contribute(uint ubountyIndex, uint amount) public{
}
function contributeWei(uint ubountyIndex) public payable{
}
function reclaim(uint ubountyIndex) public {
}
function reclaimable(uint ubountyIndex) public view returns(bool){
}
function reclaimableNow(uint ubountyIndex) public view returns(bool){
}
function transferFrom(address from, address to, uint amount) internal {
}
function transferEth(uint ubountyIndex, address payable to, uint amount) internal {
}
function bountyAmount(uint ubountyIndex) public view returns(uint){
}
function weiBountyAmount(uint ubountyIndex) public view returns(uint){
}
function createBountyChest() public {
}
function setFee(uint _fee) public {
}
function setWaiver(uint _waiver) public {
}
function satisfiesWaiver(address poster) public view returns(bool){
}
}
| ubounties[ubountyIndex].hunterIndex==0||msg.sender==userList[ubounties[ubountyIndex].hunterIndex],"You are not the bounty hunter" | 376,327 | ubounties[ubountyIndex].hunterIndex==0||msg.sender==userList[ubounties[ubountyIndex].hunterIndex] |
"This submission has already been approved" | pragma solidity ^0.6.10;
//Contract deployed on ropsten: 0xb4b333123caf6b29da37e7973aceed4e82d8206b
//Test Cash contract: 0x0f54093364b396461AAdf85C015Db597AAb56203
//Mainnet: 0x73aa31Cd548AC14713F778f454348d90564e2dE1
//Devcash: 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a
abstract contract ERC20{
function balanceOf(address who) public virtual view returns (uint256);
function transfer(address to, uint256 value) public virtual returns (bool);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
}
abstract contract ERC20Approve {
function approve(address spender, uint256 value) public virtual returns (bool);
}
contract bountyChest{
address payable creator;
constructor () public {
}
receive() external payable{
}
function transfer(address payable to, uint amount) public payable{
}
}
contract ubountyCreator{
string public version = "ubounties-v0.8b";
event created(uint uBountyIndex,uint bountiesAvailable, uint tokenAmount, uint weiAmount); //add a
event submitted(uint uBountyIndex, uint submissionIndex);
event revised(uint uBountyIndex,uint submissionIndex, uint revisionIndex);
event approved(uint uBountyIndex, uint submissionIndex, string feedback);
event rejected(uint uBountyIndex, uint submissionIndex, string feedback);
event revisionRequested(uint uBountyIndex, uint submissionIndex, string feedback);
event rewarded(uint uBountyIndex, uint submissionIndex, address Hunter, uint tokenAmount,uint weiAmount);
event reclaimed(uint uBountyIndex, uint tokenAmount, uint weiAmount);
event completed(uint uBountyIndex);
event feeChange(uint oldFee, uint newFee);
event waiverChange(uint oldWaiver, uint newWaiver);
address public devcash = 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a;
address public admin;
address payable public collector = 0xB1F445F64CDDe81d58c26ab1C340FE2a82F55A4C;
uint public fee;
uint public waiver;
struct submission{
uint32 submitterIndex;
string submissionString;
bool approved;
mapping(uint=>string) revisions;
uint8 numRevisions;
}
struct ubounty{
uint8 available; //rename to avaiable
uint8 numSubmissions;
uint32 hunterIndex;
uint32 creatorIndex;
uint32 bountyChestIndex;
uint48 deadline;
string name;
string description;
mapping(uint => submission) submissions;
}
mapping(uint => ubounty) public ubounties;
uint public numUbounties;
function getSubmission(uint ubountyIndex, uint submissionIndex) public view returns(string memory,address, bool,uint) {
}
function getRevision(uint ubountyIndex,uint submissionIndex, uint revisionIndex) public view returns (string memory){
}
mapping(address=>uint32) bountyChests; //mapping bounty chest address to bounty chest index
address payable[] public bCList; //list of bounty chest addresses
uint[] public freeBC; // list of unused bounty chests
function numBC() public view returns(uint){
}
mapping(address => uint32) public users;
address payable[] public userList;
function numUsers() public view returns(uint){
}
constructor() public {
}
//rename numleft to numavailable
function postOpenBounty(
string memory name,
string memory description,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function postPersonalBounty(
string memory name,
string memory description,
address payable hunter,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function awardOpenBounty(uint ubountyIndex, address payable hunter) public{
}
function awardPersonalBounty(string memory name, string memory description, address payable hunter, uint tokenAmount) public payable {
}
function getFee(address Poster) public view returns(uint _fee) {
}
function addUser(address payable user) public {
}
function getBountyChest() internal returns(address payable bCAddress){
}
function setUbounty(
uint32 creatorIndex,
uint32 hunterIndex,
uint8 available,
string memory name,
string memory description,
uint32 bountyChestIndex,
uint48 deadline
) internal {
}
function submit(uint ubountyIndex, string memory submissionString) public {
}
function revise(uint ubountyIndex, uint32 submissionIndex, string memory revisionString) public {
require(msg.sender==userList[ubounties[ubountyIndex].submissions[submissionIndex].submitterIndex],"You are not the submitter");
require(ubounties[ubountyIndex].available>0,"This bounty is inactive"); //make sure available is more than 0
require(<FILL_ME>)
uint8 numRevisions = ubounties[ubountyIndex].submissions[submissionIndex].numRevisions;
ubounties[ubountyIndex].submissions[submissionIndex].revisions[numRevisions] = revisionString;
emit revised(ubountyIndex,submissionIndex,numRevisions);
ubounties[ubountyIndex].submissions[submissionIndex].numRevisions++;
}
function approve(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function reject(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function requestRevision(uint ubountyIndex,uint submissionIndex,string memory feedback) public {
}
function reward(uint ubountyIndex, uint submissionIndex, address payable hunter) internal {
}
function contribute(uint ubountyIndex, uint amount) public{
}
function contributeWei(uint ubountyIndex) public payable{
}
function reclaim(uint ubountyIndex) public {
}
function reclaimable(uint ubountyIndex) public view returns(bool){
}
function reclaimableNow(uint ubountyIndex) public view returns(bool){
}
function transferFrom(address from, address to, uint amount) internal {
}
function transferEth(uint ubountyIndex, address payable to, uint amount) internal {
}
function bountyAmount(uint ubountyIndex) public view returns(uint){
}
function weiBountyAmount(uint ubountyIndex) public view returns(uint){
}
function createBountyChest() public {
}
function setFee(uint _fee) public {
}
function setWaiver(uint _waiver) public {
}
function satisfiesWaiver(address poster) public view returns(bool){
}
}
| ubounties[ubountyIndex].submissions[submissionIndex].approved==false,"This submission has already been approved" | 376,327 | ubounties[ubountyIndex].submissions[submissionIndex].approved==false |
"This bounty was created without a deadline, and is not reclaimable" | pragma solidity ^0.6.10;
//Contract deployed on ropsten: 0xb4b333123caf6b29da37e7973aceed4e82d8206b
//Test Cash contract: 0x0f54093364b396461AAdf85C015Db597AAb56203
//Mainnet: 0x73aa31Cd548AC14713F778f454348d90564e2dE1
//Devcash: 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a
abstract contract ERC20{
function balanceOf(address who) public virtual view returns (uint256);
function transfer(address to, uint256 value) public virtual returns (bool);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
}
abstract contract ERC20Approve {
function approve(address spender, uint256 value) public virtual returns (bool);
}
contract bountyChest{
address payable creator;
constructor () public {
}
receive() external payable{
}
function transfer(address payable to, uint amount) public payable{
}
}
contract ubountyCreator{
string public version = "ubounties-v0.8b";
event created(uint uBountyIndex,uint bountiesAvailable, uint tokenAmount, uint weiAmount); //add a
event submitted(uint uBountyIndex, uint submissionIndex);
event revised(uint uBountyIndex,uint submissionIndex, uint revisionIndex);
event approved(uint uBountyIndex, uint submissionIndex, string feedback);
event rejected(uint uBountyIndex, uint submissionIndex, string feedback);
event revisionRequested(uint uBountyIndex, uint submissionIndex, string feedback);
event rewarded(uint uBountyIndex, uint submissionIndex, address Hunter, uint tokenAmount,uint weiAmount);
event reclaimed(uint uBountyIndex, uint tokenAmount, uint weiAmount);
event completed(uint uBountyIndex);
event feeChange(uint oldFee, uint newFee);
event waiverChange(uint oldWaiver, uint newWaiver);
address public devcash = 0x0fca8Fdb0FB115A33BAadEc6e7A141FFC1bC7d5a;
address public admin;
address payable public collector = 0xB1F445F64CDDe81d58c26ab1C340FE2a82F55A4C;
uint public fee;
uint public waiver;
struct submission{
uint32 submitterIndex;
string submissionString;
bool approved;
mapping(uint=>string) revisions;
uint8 numRevisions;
}
struct ubounty{
uint8 available; //rename to avaiable
uint8 numSubmissions;
uint32 hunterIndex;
uint32 creatorIndex;
uint32 bountyChestIndex;
uint48 deadline;
string name;
string description;
mapping(uint => submission) submissions;
}
mapping(uint => ubounty) public ubounties;
uint public numUbounties;
function getSubmission(uint ubountyIndex, uint submissionIndex) public view returns(string memory,address, bool,uint) {
}
function getRevision(uint ubountyIndex,uint submissionIndex, uint revisionIndex) public view returns (string memory){
}
mapping(address=>uint32) bountyChests; //mapping bounty chest address to bounty chest index
address payable[] public bCList; //list of bounty chest addresses
uint[] public freeBC; // list of unused bounty chests
function numBC() public view returns(uint){
}
mapping(address => uint32) public users;
address payable[] public userList;
function numUsers() public view returns(uint){
}
constructor() public {
}
//rename numleft to numavailable
function postOpenBounty(
string memory name,
string memory description,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function postPersonalBounty(
string memory name,
string memory description,
address payable hunter,
uint8 available,
uint amount,
uint48 deadline
) public payable{
}
function awardOpenBounty(uint ubountyIndex, address payable hunter) public{
}
function awardPersonalBounty(string memory name, string memory description, address payable hunter, uint tokenAmount) public payable {
}
function getFee(address Poster) public view returns(uint _fee) {
}
function addUser(address payable user) public {
}
function getBountyChest() internal returns(address payable bCAddress){
}
function setUbounty(
uint32 creatorIndex,
uint32 hunterIndex,
uint8 available,
string memory name,
string memory description,
uint32 bountyChestIndex,
uint48 deadline
) internal {
}
function submit(uint ubountyIndex, string memory submissionString) public {
}
function revise(uint ubountyIndex, uint32 submissionIndex, string memory revisionString) public {
}
function approve(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function reject(uint ubountyIndex,uint submissionIndex,string memory feedback) public{
}
function requestRevision(uint ubountyIndex,uint submissionIndex,string memory feedback) public {
}
function reward(uint ubountyIndex, uint submissionIndex, address payable hunter) internal {
}
function contribute(uint ubountyIndex, uint amount) public{
}
function contributeWei(uint ubountyIndex) public payable{
}
function reclaim(uint ubountyIndex) public {
require(users[msg.sender]==ubounties[ubountyIndex].creatorIndex,"You are not the bounty creator");
require(<FILL_ME>)
require(now>ubounties[ubountyIndex].deadline,"The bounty deadline has not yet elapsed");
require(ubounties[ubountyIndex].available>0,"This bounty is inactive");
uint weiAmount = weiBountyAmount(ubountyIndex);
emit reclaimed(ubountyIndex,bountyAmount(ubountyIndex),weiAmount);
transferFrom(bCList[ubounties[ubountyIndex].bountyChestIndex],msg.sender,bountyAmount(ubountyIndex));
transferEth(ubountyIndex,msg.sender,weiAmount);
freeBC.push(ubounties[ubountyIndex].bountyChestIndex);
ubounties[ubountyIndex].available = 0;
for(uint i=0;i<ubounties[ubountyIndex].numSubmissions&&i<1800;i++){
if(ubounties[ubountyIndex].submissions[i].approved==false){
emit rejected(ubountyIndex,i,"bounty has been reclaimed");
}
}
}
function reclaimable(uint ubountyIndex) public view returns(bool){
}
function reclaimableNow(uint ubountyIndex) public view returns(bool){
}
function transferFrom(address from, address to, uint amount) internal {
}
function transferEth(uint ubountyIndex, address payable to, uint amount) internal {
}
function bountyAmount(uint ubountyIndex) public view returns(uint){
}
function weiBountyAmount(uint ubountyIndex) public view returns(uint){
}
function createBountyChest() public {
}
function setFee(uint _fee) public {
}
function setWaiver(uint _waiver) public {
}
function satisfiesWaiver(address poster) public view returns(bool){
}
}
| ubounties[ubountyIndex].deadline!=2**48-1,"This bounty was created without a deadline, and is not reclaimable" | 376,327 | ubounties[ubountyIndex].deadline!=2**48-1 |
"Ownership already transfered" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
/// @title More Adventure Gold for mLoot holders
/// @author Dennison Bertram <https://twitter.com/dennisonbertram>
/// @notice This contract mints Adventure Gold for Loot holders and provides
/// administrative functions to the Loot DAO. It allows:
/// * Loot holders to claim Adventure Gold
/// * A DAO to set seasons for new opportunities to claim Adventure Gold
/// * A DAO to mint Adventure Gold for use within the Loot ecosystem
/// @custom-unaudited This contract has not been audited. Use at your own risk.
/// @custom-governance is built in from the start, no need to trust 3rd party.
/// @custom-originalAuthor Will Papper <https://twitter.com/WillPapper>
import "./NewGoldBase.sol";
import "@openzeppelin/[email protected]/token/ERC721/extensions/IERC721Enumerable.sol";
contract MoreAdventureGold is NewGoldBase {
// MoreLoot contract is available at https://etherscan.io/address/0x1dfe7Ca09e99d10835Bf73044a23B73Fc20623DF
address public lootContractAddress =
0x1dfe7Ca09e99d10835Bf73044a23B73Fc20623DF;
IERC721Enumerable public lootContract;
// Give out 1,000 Adventure Gold for every Loot Bag that a user holds
uint256 public adventureGoldPerTokenId = 1000 * (10**decimals());
// tokenIdStart of 1 is based on the following lines in the Loot contract:
/**
function claim(uint256 tokenId) public nonReentrant {
require(tokenId > 0 && tokenId < 7778, "Token ID invalid");
_safeMint(_msgSender(), tokenId);
}
*/
uint256 public tokenIdStart = 8001;
// Seasons are used to allow users to claim tokens regularly. Seasons are
// decided by the DAO.
uint256 public season = 0;
bool public transferedOwnership = false;
// Track claimed tokens within a season
// IMPORTANT: The format of the mapping is:
// claimedForSeason[season][tokenId][claimed]
mapping(uint256 => mapping(uint256 => bool)) public seasonClaimedByTokenId;
constructor() Ownable() NewGoldBase(){
}
function transferOwnershipOneTime(address newOwner) public {
require(owner() == msg.sender, "You don't have authority");
require(<FILL_ME>)
transferOwnership(newOwner);
}
/// @notice Claim Adventure Gold for a given Loot ID
/// @param tokenId The tokenId of the Loot NFT
function claimById(uint256 tokenId) external {
}
/// @notice Claim Adventure Gold for all tokens owned by the sender
/// @notice This function will run out of gas if you have too much loot! If
/// this is a concern, you should use claimRangeForOwner and claim Adventure
/// Gold in batches.
function claimAllForOwner() external {
}
/// @notice Claim Adventure Gold for all tokens owned by the sender within a
/// given range
/// @notice This function is useful if you own too much Loot to claim all at
/// once or if you want to leave some Loot unclaimed. If you leave Loot
/// unclaimed, however, you cannot claim it once the next season starts.
function claimRangeForOwner(uint256 ownerIndexStart, uint256 ownerIndexEnd)
external
{
}
/// @dev Internal function to mint Loot upon claiming
function _claim(uint256 tokenId, address tokenOwner) internal {
}
/// @notice Allows the DAO to mint new tokens for use within the Loot
/// Ecosystem
/// @param amountDisplayValue The amount of Loot to mint. This should be
/// input as the display value, not in raw decimals. If you want to mint
/// 100 Loot, you should enter "100" rather than the value of 100 * 10^18.
function daoMint(uint256 amountDisplayValue) external onlyOwner {
}
/// @notice Allows the DAO to set a new contract address for Loot. This is
/// relevant in the event that Loot migrates to a new contract.
/// @param lootContractAddress_ The new contract address for Loot
function daoSetLootContractAddress(address lootContractAddress_)
external
onlyOwner
{
}
/// @notice Allows the DAO to set the token IDs that are eligible to claim
/// Loot
/// @param tokenIdStart_ The start of the eligible token range
/// @dev This is relevant in case a future Loot contract has a different
/// total supply of Loot
function daoSetTokenIdRange(uint256 tokenIdStart_)
external
onlyOwner
{
}
/// @notice Allows the DAO to set a season for new Adventure Gold claims
/// @param season_ The season to use for claiming Loot
function daoSetSeason(uint256 season_) public onlyOwner {
}
/// @notice Allows the DAO to set the amount of Adventure Gold that is
/// claimed per token ID
/// @param adventureGoldDisplayValue The amount of Loot a user can claim.
/// This should be input as the display value, not in raw decimals. If you
/// want to mint 100 Loot, you should enter "100" rather than the value of
/// 100 * 10^18.
function daoSetAdventureGoldPerTokenId(uint256 adventureGoldDisplayValue)
public
onlyOwner
{
}
/// @notice Allows the DAO to set the season and Adventure Gold per token ID
/// in one transaction. This ensures that there is not a gap where a user
/// can claim more Adventure Gold than others
/// @param season_ The season to use for claiming loot
/// @param adventureGoldDisplayValue The amount of Loot a user can claim.
/// This should be input as the display value, not in raw decimals. If you
/// want to mint 100 Loot, you should enter "100" rather than the value of
/// 100 * 10^18.
/// @dev We would save a tiny amount of gas by modifying the season and
/// adventureGold variables directly. It is better practice for security,
/// however, to avoid repeating code. This function is so rarely used that
/// it's not worth moving these values into their own internal function to
/// skip the gas used on the modifier check.
function daoSetSeasonAndAdventureGoldPerTokenID(
uint256 season_,
uint256 adventureGoldDisplayValue
) external onlyOwner {
}
}
| !transferedOwnership,"Ownership already transfered" | 376,345 | !transferedOwnership |
"MUST_OWN_TOKEN_ID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
/// @title More Adventure Gold for mLoot holders
/// @author Dennison Bertram <https://twitter.com/dennisonbertram>
/// @notice This contract mints Adventure Gold for Loot holders and provides
/// administrative functions to the Loot DAO. It allows:
/// * Loot holders to claim Adventure Gold
/// * A DAO to set seasons for new opportunities to claim Adventure Gold
/// * A DAO to mint Adventure Gold for use within the Loot ecosystem
/// @custom-unaudited This contract has not been audited. Use at your own risk.
/// @custom-governance is built in from the start, no need to trust 3rd party.
/// @custom-originalAuthor Will Papper <https://twitter.com/WillPapper>
import "./NewGoldBase.sol";
import "@openzeppelin/[email protected]/token/ERC721/extensions/IERC721Enumerable.sol";
contract MoreAdventureGold is NewGoldBase {
// MoreLoot contract is available at https://etherscan.io/address/0x1dfe7Ca09e99d10835Bf73044a23B73Fc20623DF
address public lootContractAddress =
0x1dfe7Ca09e99d10835Bf73044a23B73Fc20623DF;
IERC721Enumerable public lootContract;
// Give out 1,000 Adventure Gold for every Loot Bag that a user holds
uint256 public adventureGoldPerTokenId = 1000 * (10**decimals());
// tokenIdStart of 1 is based on the following lines in the Loot contract:
/**
function claim(uint256 tokenId) public nonReentrant {
require(tokenId > 0 && tokenId < 7778, "Token ID invalid");
_safeMint(_msgSender(), tokenId);
}
*/
uint256 public tokenIdStart = 8001;
// Seasons are used to allow users to claim tokens regularly. Seasons are
// decided by the DAO.
uint256 public season = 0;
bool public transferedOwnership = false;
// Track claimed tokens within a season
// IMPORTANT: The format of the mapping is:
// claimedForSeason[season][tokenId][claimed]
mapping(uint256 => mapping(uint256 => bool)) public seasonClaimedByTokenId;
constructor() Ownable() NewGoldBase(){
}
function transferOwnershipOneTime(address newOwner) public {
}
/// @notice Claim Adventure Gold for a given Loot ID
/// @param tokenId The tokenId of the Loot NFT
function claimById(uint256 tokenId) external {
// Follow the Checks-Effects-Interactions pattern to prevent reentrancy
// attacks
// Checks
// Check that the msgSender owns the token that is being claimed
require(<FILL_ME>)
// Further Checks, Effects, and Interactions are contained within the
// _claim() function
_claim(tokenId, _msgSender());
}
/// @notice Claim Adventure Gold for all tokens owned by the sender
/// @notice This function will run out of gas if you have too much loot! If
/// this is a concern, you should use claimRangeForOwner and claim Adventure
/// Gold in batches.
function claimAllForOwner() external {
}
/// @notice Claim Adventure Gold for all tokens owned by the sender within a
/// given range
/// @notice This function is useful if you own too much Loot to claim all at
/// once or if you want to leave some Loot unclaimed. If you leave Loot
/// unclaimed, however, you cannot claim it once the next season starts.
function claimRangeForOwner(uint256 ownerIndexStart, uint256 ownerIndexEnd)
external
{
}
/// @dev Internal function to mint Loot upon claiming
function _claim(uint256 tokenId, address tokenOwner) internal {
}
/// @notice Allows the DAO to mint new tokens for use within the Loot
/// Ecosystem
/// @param amountDisplayValue The amount of Loot to mint. This should be
/// input as the display value, not in raw decimals. If you want to mint
/// 100 Loot, you should enter "100" rather than the value of 100 * 10^18.
function daoMint(uint256 amountDisplayValue) external onlyOwner {
}
/// @notice Allows the DAO to set a new contract address for Loot. This is
/// relevant in the event that Loot migrates to a new contract.
/// @param lootContractAddress_ The new contract address for Loot
function daoSetLootContractAddress(address lootContractAddress_)
external
onlyOwner
{
}
/// @notice Allows the DAO to set the token IDs that are eligible to claim
/// Loot
/// @param tokenIdStart_ The start of the eligible token range
/// @dev This is relevant in case a future Loot contract has a different
/// total supply of Loot
function daoSetTokenIdRange(uint256 tokenIdStart_)
external
onlyOwner
{
}
/// @notice Allows the DAO to set a season for new Adventure Gold claims
/// @param season_ The season to use for claiming Loot
function daoSetSeason(uint256 season_) public onlyOwner {
}
/// @notice Allows the DAO to set the amount of Adventure Gold that is
/// claimed per token ID
/// @param adventureGoldDisplayValue The amount of Loot a user can claim.
/// This should be input as the display value, not in raw decimals. If you
/// want to mint 100 Loot, you should enter "100" rather than the value of
/// 100 * 10^18.
function daoSetAdventureGoldPerTokenId(uint256 adventureGoldDisplayValue)
public
onlyOwner
{
}
/// @notice Allows the DAO to set the season and Adventure Gold per token ID
/// in one transaction. This ensures that there is not a gap where a user
/// can claim more Adventure Gold than others
/// @param season_ The season to use for claiming loot
/// @param adventureGoldDisplayValue The amount of Loot a user can claim.
/// This should be input as the display value, not in raw decimals. If you
/// want to mint 100 Loot, you should enter "100" rather than the value of
/// 100 * 10^18.
/// @dev We would save a tiny amount of gas by modifying the season and
/// adventureGold variables directly. It is better practice for security,
/// however, to avoid repeating code. This function is so rarely used that
/// it's not worth moving these values into their own internal function to
/// skip the gas used on the modifier check.
function daoSetSeasonAndAdventureGoldPerTokenID(
uint256 season_,
uint256 adventureGoldDisplayValue
) external onlyOwner {
}
}
| _msgSender()==lootContract.ownerOf(tokenId),"MUST_OWN_TOKEN_ID" | 376,345 | _msgSender()==lootContract.ownerOf(tokenId) |
"GOLD_CLAIMED_FOR_TOKEN_ID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
/// @title More Adventure Gold for mLoot holders
/// @author Dennison Bertram <https://twitter.com/dennisonbertram>
/// @notice This contract mints Adventure Gold for Loot holders and provides
/// administrative functions to the Loot DAO. It allows:
/// * Loot holders to claim Adventure Gold
/// * A DAO to set seasons for new opportunities to claim Adventure Gold
/// * A DAO to mint Adventure Gold for use within the Loot ecosystem
/// @custom-unaudited This contract has not been audited. Use at your own risk.
/// @custom-governance is built in from the start, no need to trust 3rd party.
/// @custom-originalAuthor Will Papper <https://twitter.com/WillPapper>
import "./NewGoldBase.sol";
import "@openzeppelin/[email protected]/token/ERC721/extensions/IERC721Enumerable.sol";
contract MoreAdventureGold is NewGoldBase {
// MoreLoot contract is available at https://etherscan.io/address/0x1dfe7Ca09e99d10835Bf73044a23B73Fc20623DF
address public lootContractAddress =
0x1dfe7Ca09e99d10835Bf73044a23B73Fc20623DF;
IERC721Enumerable public lootContract;
// Give out 1,000 Adventure Gold for every Loot Bag that a user holds
uint256 public adventureGoldPerTokenId = 1000 * (10**decimals());
// tokenIdStart of 1 is based on the following lines in the Loot contract:
/**
function claim(uint256 tokenId) public nonReentrant {
require(tokenId > 0 && tokenId < 7778, "Token ID invalid");
_safeMint(_msgSender(), tokenId);
}
*/
uint256 public tokenIdStart = 8001;
// Seasons are used to allow users to claim tokens regularly. Seasons are
// decided by the DAO.
uint256 public season = 0;
bool public transferedOwnership = false;
// Track claimed tokens within a season
// IMPORTANT: The format of the mapping is:
// claimedForSeason[season][tokenId][claimed]
mapping(uint256 => mapping(uint256 => bool)) public seasonClaimedByTokenId;
constructor() Ownable() NewGoldBase(){
}
function transferOwnershipOneTime(address newOwner) public {
}
/// @notice Claim Adventure Gold for a given Loot ID
/// @param tokenId The tokenId of the Loot NFT
function claimById(uint256 tokenId) external {
}
/// @notice Claim Adventure Gold for all tokens owned by the sender
/// @notice This function will run out of gas if you have too much loot! If
/// this is a concern, you should use claimRangeForOwner and claim Adventure
/// Gold in batches.
function claimAllForOwner() external {
}
/// @notice Claim Adventure Gold for all tokens owned by the sender within a
/// given range
/// @notice This function is useful if you own too much Loot to claim all at
/// once or if you want to leave some Loot unclaimed. If you leave Loot
/// unclaimed, however, you cannot claim it once the next season starts.
function claimRangeForOwner(uint256 ownerIndexStart, uint256 ownerIndexEnd)
external
{
}
/// @dev Internal function to mint Loot upon claiming
function _claim(uint256 tokenId, address tokenOwner) internal {
// Checks
// Check that the token ID is in range
// We use >= and <= to here because all of the token IDs are 0-indexed
require(
tokenId >= tokenIdStart,
"TOKEN_ID_OUT_OF_RANGE"
);
// Check that Adventure Gold have not already been claimed this season
// for a given tokenId
require(<FILL_ME>)
// Effects
// Mark that Adventure Gold has been claimed for this season for the
// given tokenId
seasonClaimedByTokenId[season][tokenId] = true;
// Interactions
// Send Adventure Gold to the owner of the token ID
_mint(tokenOwner, adventureGoldPerTokenId);
}
/// @notice Allows the DAO to mint new tokens for use within the Loot
/// Ecosystem
/// @param amountDisplayValue The amount of Loot to mint. This should be
/// input as the display value, not in raw decimals. If you want to mint
/// 100 Loot, you should enter "100" rather than the value of 100 * 10^18.
function daoMint(uint256 amountDisplayValue) external onlyOwner {
}
/// @notice Allows the DAO to set a new contract address for Loot. This is
/// relevant in the event that Loot migrates to a new contract.
/// @param lootContractAddress_ The new contract address for Loot
function daoSetLootContractAddress(address lootContractAddress_)
external
onlyOwner
{
}
/// @notice Allows the DAO to set the token IDs that are eligible to claim
/// Loot
/// @param tokenIdStart_ The start of the eligible token range
/// @dev This is relevant in case a future Loot contract has a different
/// total supply of Loot
function daoSetTokenIdRange(uint256 tokenIdStart_)
external
onlyOwner
{
}
/// @notice Allows the DAO to set a season for new Adventure Gold claims
/// @param season_ The season to use for claiming Loot
function daoSetSeason(uint256 season_) public onlyOwner {
}
/// @notice Allows the DAO to set the amount of Adventure Gold that is
/// claimed per token ID
/// @param adventureGoldDisplayValue The amount of Loot a user can claim.
/// This should be input as the display value, not in raw decimals. If you
/// want to mint 100 Loot, you should enter "100" rather than the value of
/// 100 * 10^18.
function daoSetAdventureGoldPerTokenId(uint256 adventureGoldDisplayValue)
public
onlyOwner
{
}
/// @notice Allows the DAO to set the season and Adventure Gold per token ID
/// in one transaction. This ensures that there is not a gap where a user
/// can claim more Adventure Gold than others
/// @param season_ The season to use for claiming loot
/// @param adventureGoldDisplayValue The amount of Loot a user can claim.
/// This should be input as the display value, not in raw decimals. If you
/// want to mint 100 Loot, you should enter "100" rather than the value of
/// 100 * 10^18.
/// @dev We would save a tiny amount of gas by modifying the season and
/// adventureGold variables directly. It is better practice for security,
/// however, to avoid repeating code. This function is so rarely used that
/// it's not worth moving these values into their own internal function to
/// skip the gas used on the modifier check.
function daoSetSeasonAndAdventureGoldPerTokenID(
uint256 season_,
uint256 adventureGoldDisplayValue
) external onlyOwner {
}
}
| !seasonClaimedByTokenId[season][tokenId],"GOLD_CLAIMED_FOR_TOKEN_ID" | 376,345 | !seasonClaimedByTokenId[season][tokenId] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './IERC20.sol';
import './ERC721.sol';
import './Ownable.sol';
interface ERC20Interface is IERC20 {
function deposit() external payable;
}
interface IApymonPack {
function increaseInsideTokenBalance(
uint256 eggId,
uint8 tokenType,
address token,
uint256 amount
) external;
}
contract Apymon is ERC721, Ownable {
using SafeMath for uint256;
string public APYMON_PROVENANCE = "";
// Maximum amount of Eggs in existance. Ever.
uint256 public constant MAX_EGG_SUPPLY = 6400;
uint256 public constant MAX_APYMON_SUPPLY = 12800;
uint256 public CREATURE_SUPPLY;
// Referral management
mapping(address => uint256) public _referralAmounts;
mapping(address => mapping(address => bool)) public _referralStatus;
IApymonPack public _apymonpack;
ERC20Interface private constant _weth = ERC20Interface(
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 // mainnet
);
address payable private constant _team = payable(
0x262655a65538C71454Cb60951BF1a79E19668218
);
address payable private constant _treasury = payable(
0xeD2D1254e79835bF5911Aa8946e23bf508477Da4
);
bool public hasSaleStarted = false;
constructor(
string memory baseURI
) ERC721("Apymon", "APYMON") {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
/**
* @dev Gets egg count to mint per once.
*/
function getMintableCount() public view returns (uint256) {
}
function getEggPrice() public view returns (uint256) {
}
function getRandomNumber(uint256 a, uint256 b) public view returns (uint256) {
}
function distributeRandomBonus(
uint8 tier
) external onlyOwner {
}
function distributeReferral(
uint256 startEggId,
uint256 endEggId
) external onlyOwner {
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory baseURI) onlyOwner external {
}
/**
* @dev Set apymon pack address
*/
function setApymonPack(address apymonpack) onlyOwner external {
}
function setProvenance(string memory _provenance) onlyOwner external {
}
/**
* @dev Mints yourself Eggs.
*/
function mintEggs(
address to,
uint256 count,
address referee
) public payable {
uint256 eggSupply = totalSupply() - CREATURE_SUPPLY;
require(
hasSaleStarted,
"Sale hasn't started."
);
require(
count > 0 && count <= getMintableCount()
);
require(<FILL_ME>)
require(
SafeMath.mul(getEggPrice(), count) == msg.value
);
for (uint256 i; i < count; i++) {
uint256 mintIndex = totalSupply() - CREATURE_SUPPLY;
_safeMint(to, mintIndex);
}
if (referee != address(0) && referee != to) {
_addReferralAmount(referee, to, msg.value);
}
}
/**
* @dev Mints creature to apymonpacks.
* Creatures must be distributed to owners of egg.
*/
function mintCreature() external returns (uint256 creatureId) {
}
/**
* @dev send eth to team and treasury.
*/
function requestFund(
uint256 amount
) external onlyOwner {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
/**
* @dev private function to record referral status.
*/
function _addReferralAmount(
address referee,
address referrer,
uint256 amount
) private {
}
}
| SafeMath.add(eggSupply,count)<=MAX_EGG_SUPPLY | 376,408 | SafeMath.add(eggSupply,count)<=MAX_EGG_SUPPLY |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './IERC20.sol';
import './ERC721.sol';
import './Ownable.sol';
interface ERC20Interface is IERC20 {
function deposit() external payable;
}
interface IApymonPack {
function increaseInsideTokenBalance(
uint256 eggId,
uint8 tokenType,
address token,
uint256 amount
) external;
}
contract Apymon is ERC721, Ownable {
using SafeMath for uint256;
string public APYMON_PROVENANCE = "";
// Maximum amount of Eggs in existance. Ever.
uint256 public constant MAX_EGG_SUPPLY = 6400;
uint256 public constant MAX_APYMON_SUPPLY = 12800;
uint256 public CREATURE_SUPPLY;
// Referral management
mapping(address => uint256) public _referralAmounts;
mapping(address => mapping(address => bool)) public _referralStatus;
IApymonPack public _apymonpack;
ERC20Interface private constant _weth = ERC20Interface(
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 // mainnet
);
address payable private constant _team = payable(
0x262655a65538C71454Cb60951BF1a79E19668218
);
address payable private constant _treasury = payable(
0xeD2D1254e79835bF5911Aa8946e23bf508477Da4
);
bool public hasSaleStarted = false;
constructor(
string memory baseURI
) ERC721("Apymon", "APYMON") {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
/**
* @dev Gets egg count to mint per once.
*/
function getMintableCount() public view returns (uint256) {
}
function getEggPrice() public view returns (uint256) {
}
function getRandomNumber(uint256 a, uint256 b) public view returns (uint256) {
}
function distributeRandomBonus(
uint8 tier
) external onlyOwner {
}
function distributeReferral(
uint256 startEggId,
uint256 endEggId
) external onlyOwner {
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory baseURI) onlyOwner external {
}
/**
* @dev Set apymon pack address
*/
function setApymonPack(address apymonpack) onlyOwner external {
}
function setProvenance(string memory _provenance) onlyOwner external {
}
/**
* @dev Mints yourself Eggs.
*/
function mintEggs(
address to,
uint256 count,
address referee
) public payable {
uint256 eggSupply = totalSupply() - CREATURE_SUPPLY;
require(
hasSaleStarted,
"Sale hasn't started."
);
require(
count > 0 && count <= getMintableCount()
);
require(
SafeMath.add(eggSupply, count) <= MAX_EGG_SUPPLY
);
require(<FILL_ME>)
for (uint256 i; i < count; i++) {
uint256 mintIndex = totalSupply() - CREATURE_SUPPLY;
_safeMint(to, mintIndex);
}
if (referee != address(0) && referee != to) {
_addReferralAmount(referee, to, msg.value);
}
}
/**
* @dev Mints creature to apymonpacks.
* Creatures must be distributed to owners of egg.
*/
function mintCreature() external returns (uint256 creatureId) {
}
/**
* @dev send eth to team and treasury.
*/
function requestFund(
uint256 amount
) external onlyOwner {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
/**
* @dev private function to record referral status.
*/
function _addReferralAmount(
address referee,
address referrer,
uint256 amount
) private {
}
}
| SafeMath.mul(getEggPrice(),count)==msg.value | 376,408 | SafeMath.mul(getEggPrice(),count)==msg.value |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './IERC20.sol';
import './ERC721.sol';
import './Ownable.sol';
interface ERC20Interface is IERC20 {
function deposit() external payable;
}
interface IApymonPack {
function increaseInsideTokenBalance(
uint256 eggId,
uint8 tokenType,
address token,
uint256 amount
) external;
}
contract Apymon is ERC721, Ownable {
using SafeMath for uint256;
string public APYMON_PROVENANCE = "";
// Maximum amount of Eggs in existance. Ever.
uint256 public constant MAX_EGG_SUPPLY = 6400;
uint256 public constant MAX_APYMON_SUPPLY = 12800;
uint256 public CREATURE_SUPPLY;
// Referral management
mapping(address => uint256) public _referralAmounts;
mapping(address => mapping(address => bool)) public _referralStatus;
IApymonPack public _apymonpack;
ERC20Interface private constant _weth = ERC20Interface(
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 // mainnet
);
address payable private constant _team = payable(
0x262655a65538C71454Cb60951BF1a79E19668218
);
address payable private constant _treasury = payable(
0xeD2D1254e79835bF5911Aa8946e23bf508477Da4
);
bool public hasSaleStarted = false;
constructor(
string memory baseURI
) ERC721("Apymon", "APYMON") {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
/**
* @dev Gets egg count to mint per once.
*/
function getMintableCount() public view returns (uint256) {
}
function getEggPrice() public view returns (uint256) {
}
function getRandomNumber(uint256 a, uint256 b) public view returns (uint256) {
}
function distributeRandomBonus(
uint8 tier
) external onlyOwner {
}
function distributeReferral(
uint256 startEggId,
uint256 endEggId
) external onlyOwner {
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory baseURI) onlyOwner external {
}
/**
* @dev Set apymon pack address
*/
function setApymonPack(address apymonpack) onlyOwner external {
}
function setProvenance(string memory _provenance) onlyOwner external {
}
/**
* @dev Mints yourself Eggs.
*/
function mintEggs(
address to,
uint256 count,
address referee
) public payable {
}
/**
* @dev Mints creature to apymonpacks.
* Creatures must be distributed to owners of egg.
*/
function mintCreature() external returns (uint256 creatureId) {
require(msg.sender == address(_apymonpack));
require(
!hasSaleStarted,
"Sale hasn't finised yet."
);
creatureId = MAX_EGG_SUPPLY + CREATURE_SUPPLY;
require(<FILL_ME>)
_safeMint(address(_apymonpack), creatureId);
CREATURE_SUPPLY++;
}
/**
* @dev send eth to team and treasury.
*/
function requestFund(
uint256 amount
) external onlyOwner {
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
/**
* @dev private function to record referral status.
*/
function _addReferralAmount(
address referee,
address referrer,
uint256 amount
) private {
}
}
| !_exists(creatureId) | 376,408 | !_exists(creatureId) |
"error" | /*
ARE YOU DEGEN?
*/
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 _initMint(address account, uint amount) internal {
}
function _emergencyWithdraw(address account, uint amount) internal {
}
function _withdraw(address account, uint amount) internal {
}
function _burn(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 DEGENFinance is ERC20, ERC20Detailed {
using SafeMath for uint;
mapping (address => bool) public degens;
constructor () public ERC20Detailed("DEGEN Finance", "DEGEN", 18) {
}
function stake(address account) public {
require(<FILL_ME>)
_stake(account);
}
function withdraw(address account, uint amount) public {
}
function emergencyWithdraw(address account, uint amount) public {
}
}
| degens[msg.sender],"error" | 376,520 | degens[msg.sender] |
"Invalid expiration timestamp" | pragma solidity ^0.6.0;
/**
* @title Expiring Multi Party Contract creator.
* @notice Factory contract to create and register new instances of expiring multiparty contracts.
* Responsible for constraining the parameters used to construct a new EMP. This creator contains a number of constraints
* that are applied to newly created expiring multi party contract. These constraints can evolve over time and are
* initially constrained to conservative values in this first iteration. Technically there is nothing in the
* ExpiringMultiParty contract requiring these constraints. However, because `createExpiringMultiParty()` is intended
* to be the only way to create valid financial contracts that are registered with the DVM (via _registerContract),
we can enforce deployment configurations here.
*/
contract ExpiringMultiPartyCreator is ContractCreator, Testable, Lockable {
using FixedPoint for FixedPoint.Unsigned;
/****************************************
* EMP CREATOR DATA STRUCTURES *
****************************************/
struct Params {
uint256 expirationTimestamp;
address collateralAddress;
bytes32 priceFeedIdentifier;
string syntheticName;
string syntheticSymbol;
FixedPoint.Unsigned collateralRequirement;
FixedPoint.Unsigned disputeBondPct;
FixedPoint.Unsigned sponsorDisputeRewardPct;
FixedPoint.Unsigned disputerDisputeRewardPct;
FixedPoint.Unsigned minSponsorTokens;
}
// - Whitelist allowed collateral currencies.
// Note: before an instantiation of ExpiringMultipartyCreator is approved to register contracts, voters should
// ensure that the ownership of this collateralTokenWhitelist has been renounced (so it is effectively frozen). One
// could also set the owner to the address of the Governor contract, but voters may find that option less preferable
// since it would force them to take a more active role in managing this financial contract template.
AddressWhitelist public collateralTokenWhitelist;
// - Address of TokenFactory to pass into newly constructed ExpiringMultiParty contracts
address public tokenFactoryAddress;
// - Discretize expirations such that they must expire on the first of each month.
mapping(uint256 => bool) public validExpirationTimestamps;
// - Time for pending withdrawal to be disputed: 120 minutes. Lower liveness increases sponsor usability.
// However, this parameter is a reflection of how long we expect it to take for liquidators to identify
// that a sponsor is undercollateralized and acquire the tokens needed to liquidate them. This is also a
// reflection of how long a malicious sponsor would need to maintain a lower-price manipulation to get
// their withdrawal processed maliciously (if set too low, it’s quite easy for malicious sponsors to
// request a withdrawal and spend gas to prevent other transactions from processing until the withdrawal
// gets approved). Ultimately, liveness is a friction to be minimized, but not critical to system function.
uint256 public constant STRICT_WITHDRAWAL_LIVENESS = 7200;
// - Time for liquidation to be disputed: 120 minutes. Similar reasoning to withdrawal liveness.
// Lower liveness is more usable for liquidators. However, the parameter is a reflection of how
// long we expect it to take disputers to notice bad liquidations. Malicious liquidators would
// also need to attack the base chain for this long to prevent dispute transactions from processing.
uint256 public constant STRICT_LIQUIDATION_LIVENESS = 7200;
event CreatedExpiringMultiParty(address indexed expiringMultiPartyAddress, address indexed deployerAddress);
/**
* @notice Constructs the ExpiringMultiPartyCreator contract.
* @param _finderAddress UMA protocol Finder used to discover other protocol contracts.
* @param _collateralTokenWhitelist UMA protocol contract to track whitelisted collateral.
* @param _tokenFactoryAddress ERC20 token factory used to deploy synthetic token instances.
* @param _timerAddress Contract that stores the current time in a testing environment.
*/
constructor(
address _finderAddress,
address _collateralTokenWhitelist,
address _tokenFactoryAddress,
address _timerAddress
) public ContractCreator(_finderAddress) Testable(_timerAddress) nonReentrant() {
}
/**
* @notice Creates an instance of expiring multi party and registers it within the registry.
* @param params is a `ConstructorParams` object from ExpiringMultiParty.
* @return address of the deployed ExpiringMultiParty contract.
*/
function createExpiringMultiParty(Params memory params) public nonReentrant() returns (address) {
}
/****************************************
* PRIVATE FUNCTIONS *
****************************************/
// Returns if expiration timestamp is on hardcoded list.
function _isValidTimestamp(uint256 timestamp) private view returns (bool) {
}
// Converts createExpiringMultiParty params to ExpiringMultiParty constructor params.
function _convertParams(Params memory params)
private
view
returns (ExpiringMultiParty.ConstructorParams memory constructorParams)
{
// Known from creator deployment.
constructorParams.finderAddress = finderAddress;
constructorParams.tokenFactoryAddress = tokenFactoryAddress;
constructorParams.timerAddress = timerAddress;
// Enforce configuration constraints.
require(<FILL_ME>)
require(bytes(params.syntheticName).length != 0, "Missing synthetic name");
require(bytes(params.syntheticSymbol).length != 0, "Missing synthetic symbol");
constructorParams.withdrawalLiveness = STRICT_WITHDRAWAL_LIVENESS;
constructorParams.liquidationLiveness = STRICT_LIQUIDATION_LIVENESS;
require(collateralTokenWhitelist.isOnWhitelist(params.collateralAddress), "Collateral is not whitelisted");
// Input from function call.
constructorParams.expirationTimestamp = params.expirationTimestamp;
constructorParams.collateralAddress = params.collateralAddress;
constructorParams.priceFeedIdentifier = params.priceFeedIdentifier;
constructorParams.syntheticName = params.syntheticName;
constructorParams.syntheticSymbol = params.syntheticSymbol;
constructorParams.collateralRequirement = params.collateralRequirement;
constructorParams.disputeBondPct = params.disputeBondPct;
constructorParams.sponsorDisputeRewardPct = params.sponsorDisputeRewardPct;
constructorParams.disputerDisputeRewardPct = params.disputerDisputeRewardPct;
constructorParams.minSponsorTokens = params.minSponsorTokens;
}
}
| _isValidTimestamp(params.expirationTimestamp),"Invalid expiration timestamp" | 376,591 | _isValidTimestamp(params.expirationTimestamp) |
"Collateral is not whitelisted" | pragma solidity ^0.6.0;
/**
* @title Expiring Multi Party Contract creator.
* @notice Factory contract to create and register new instances of expiring multiparty contracts.
* Responsible for constraining the parameters used to construct a new EMP. This creator contains a number of constraints
* that are applied to newly created expiring multi party contract. These constraints can evolve over time and are
* initially constrained to conservative values in this first iteration. Technically there is nothing in the
* ExpiringMultiParty contract requiring these constraints. However, because `createExpiringMultiParty()` is intended
* to be the only way to create valid financial contracts that are registered with the DVM (via _registerContract),
we can enforce deployment configurations here.
*/
contract ExpiringMultiPartyCreator is ContractCreator, Testable, Lockable {
using FixedPoint for FixedPoint.Unsigned;
/****************************************
* EMP CREATOR DATA STRUCTURES *
****************************************/
struct Params {
uint256 expirationTimestamp;
address collateralAddress;
bytes32 priceFeedIdentifier;
string syntheticName;
string syntheticSymbol;
FixedPoint.Unsigned collateralRequirement;
FixedPoint.Unsigned disputeBondPct;
FixedPoint.Unsigned sponsorDisputeRewardPct;
FixedPoint.Unsigned disputerDisputeRewardPct;
FixedPoint.Unsigned minSponsorTokens;
}
// - Whitelist allowed collateral currencies.
// Note: before an instantiation of ExpiringMultipartyCreator is approved to register contracts, voters should
// ensure that the ownership of this collateralTokenWhitelist has been renounced (so it is effectively frozen). One
// could also set the owner to the address of the Governor contract, but voters may find that option less preferable
// since it would force them to take a more active role in managing this financial contract template.
AddressWhitelist public collateralTokenWhitelist;
// - Address of TokenFactory to pass into newly constructed ExpiringMultiParty contracts
address public tokenFactoryAddress;
// - Discretize expirations such that they must expire on the first of each month.
mapping(uint256 => bool) public validExpirationTimestamps;
// - Time for pending withdrawal to be disputed: 120 minutes. Lower liveness increases sponsor usability.
// However, this parameter is a reflection of how long we expect it to take for liquidators to identify
// that a sponsor is undercollateralized and acquire the tokens needed to liquidate them. This is also a
// reflection of how long a malicious sponsor would need to maintain a lower-price manipulation to get
// their withdrawal processed maliciously (if set too low, it’s quite easy for malicious sponsors to
// request a withdrawal and spend gas to prevent other transactions from processing until the withdrawal
// gets approved). Ultimately, liveness is a friction to be minimized, but not critical to system function.
uint256 public constant STRICT_WITHDRAWAL_LIVENESS = 7200;
// - Time for liquidation to be disputed: 120 minutes. Similar reasoning to withdrawal liveness.
// Lower liveness is more usable for liquidators. However, the parameter is a reflection of how
// long we expect it to take disputers to notice bad liquidations. Malicious liquidators would
// also need to attack the base chain for this long to prevent dispute transactions from processing.
uint256 public constant STRICT_LIQUIDATION_LIVENESS = 7200;
event CreatedExpiringMultiParty(address indexed expiringMultiPartyAddress, address indexed deployerAddress);
/**
* @notice Constructs the ExpiringMultiPartyCreator contract.
* @param _finderAddress UMA protocol Finder used to discover other protocol contracts.
* @param _collateralTokenWhitelist UMA protocol contract to track whitelisted collateral.
* @param _tokenFactoryAddress ERC20 token factory used to deploy synthetic token instances.
* @param _timerAddress Contract that stores the current time in a testing environment.
*/
constructor(
address _finderAddress,
address _collateralTokenWhitelist,
address _tokenFactoryAddress,
address _timerAddress
) public ContractCreator(_finderAddress) Testable(_timerAddress) nonReentrant() {
}
/**
* @notice Creates an instance of expiring multi party and registers it within the registry.
* @param params is a `ConstructorParams` object from ExpiringMultiParty.
* @return address of the deployed ExpiringMultiParty contract.
*/
function createExpiringMultiParty(Params memory params) public nonReentrant() returns (address) {
}
/****************************************
* PRIVATE FUNCTIONS *
****************************************/
// Returns if expiration timestamp is on hardcoded list.
function _isValidTimestamp(uint256 timestamp) private view returns (bool) {
}
// Converts createExpiringMultiParty params to ExpiringMultiParty constructor params.
function _convertParams(Params memory params)
private
view
returns (ExpiringMultiParty.ConstructorParams memory constructorParams)
{
// Known from creator deployment.
constructorParams.finderAddress = finderAddress;
constructorParams.tokenFactoryAddress = tokenFactoryAddress;
constructorParams.timerAddress = timerAddress;
// Enforce configuration constraints.
require(_isValidTimestamp(params.expirationTimestamp), "Invalid expiration timestamp");
require(bytes(params.syntheticName).length != 0, "Missing synthetic name");
require(bytes(params.syntheticSymbol).length != 0, "Missing synthetic symbol");
constructorParams.withdrawalLiveness = STRICT_WITHDRAWAL_LIVENESS;
constructorParams.liquidationLiveness = STRICT_LIQUIDATION_LIVENESS;
require(<FILL_ME>)
// Input from function call.
constructorParams.expirationTimestamp = params.expirationTimestamp;
constructorParams.collateralAddress = params.collateralAddress;
constructorParams.priceFeedIdentifier = params.priceFeedIdentifier;
constructorParams.syntheticName = params.syntheticName;
constructorParams.syntheticSymbol = params.syntheticSymbol;
constructorParams.collateralRequirement = params.collateralRequirement;
constructorParams.disputeBondPct = params.disputeBondPct;
constructorParams.sponsorDisputeRewardPct = params.sponsorDisputeRewardPct;
constructorParams.disputerDisputeRewardPct = params.disputerDisputeRewardPct;
constructorParams.minSponsorTokens = params.minSponsorTokens;
}
}
| collateralTokenWhitelist.isOnWhitelist(params.collateralAddress),"Collateral is not whitelisted" | 376,591 | collateralTokenWhitelist.isOnWhitelist(params.collateralAddress) |
"This Contract is depreciated" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// import "hardhat/console.sol";
// _________ ________ _____________________
// \_ ___ \ \_____ \\______ \_ _____/
// / \ \/ / | \| _/| __)_
// \ \____/ | \ | \| \
// \______ /\_______ /____|_ /_______ /
// \/ \/ \/ \/
// ___________.____ _____ _________ ___ ___
// \_ _____/| | / _ \ / _____// | \
// | __) | | / /_\ \ \_____ \/ ~ \
// | \ | |___/ | \/ \ Y /
// \___ / |_______ \____|__ /_______ /\___|_ /
// \/ \/ \/ \/ \/
// _____ ____________________.________________________ _____ ___________________
// / _ \\______ \______ \ \__ ___/\______ \ / _ \ / _____/\_ _____/
// / /_\ \| _/| | _/ | | | | _/ / /_\ \/ \ ___ | __)_
// / | \ | \| | \ | | | | | \/ | \ \_\ \| \
// \____|__ /____|_ /|______ /___| |____| |____|_ /\____|__ /\______ /_______ /
// \/ \/ \/ \/ \/ \/ \/
// Controller
//
// This contract checks for opportunities to gain profit for all of DEXs out there
// But especially the CORE ecosystem because this contract can tell another contrac to turn feeOff for the duration of its trades
// By arbitraging all existing pools, and transfering profits to FeeSplitter
// That will add rewards to specific pools to keep them at X% APY
// And add liquidity and subsequently burn the liquidity tokens after all pools reach this threashold
//
// .edee... ..... .eeec. ..eee..
// .d*" """"*e..d*"""""**e..e*"" "*c.d"" ""*e.
// z" "$ $"" *F **e.
// z" "c d" *. "$.
// .F " " 'F
// d J%
// 3 . e"
// 4r e" . d"
// $ .d" . .F z ..zeeeeed"
// "*beeeP" P d e. $**"" "
// "*b. Jbc. z*%e.. .$**eeeeP"
// "*beee* "$$eeed" ^$$$"" "
// '$$. .$$$c
// "$$. e$$*$$c
// "$$..$$P" '$$r
// "$$$$" "$$. .d
// z. .$$$" "$$. .dP"
// ^*e e$$" "$$. .e$"
// *b. .$$P" "$$. z$"
// "$c e$$" "$$.z$*"
// ^*e$$P" "$$$"
// *$$ "$$r
// '$$F .$$P
// $$$ z$$"
// 4$$ d$$b.
// .$$% .$$*"*$$e.
// e$$$*" z$$" "*$$e.
// 4$$" d$P" "*$$e.
// $P .d$$$c "*$$e..
// d$" z$$" *$b. "*$L
// 4$" e$P" "*$c ^$$
// $" .d$" "$$. ^$r
// dP z$$" ^*$e. "b
// 4$ e$P "$$ "
// J$F $$
// $$ .$F
// 4$" $P"
// $" dP kjRWG0tKD4A
//
// I'll have you know...
interface IFlashArbitrageExecutor {
function getStrategyProfitInReturnToken(address[] memory pairs, uint256[] memory feeOnTransfers, bool[] memory token0Out) external view returns (uint256);
function executeStrategy(uint256) external;
// Strategy that self calculates best input but costs gas
function executeStrategy(address[] memory pairs, uint256[] memory feeOnTransfers, bool[] memory token0Out, bool cBTCSupport) external;
// strategy that does not calculate the best input meant for miners
function executeStrategy(uint256 borrowAmt, address[] memory pairs, uint256[] memory feeOnTransfers, bool[] memory token0Out, bool cBTCSupport) external;
function getOptimalInput(address[] memory pairs, uint256[] memory feeOnTransfers, bool[] memory token0Out) external view returns (uint256);
}
contract FlashArbitrageController is Ownable {
using SafeMath for uint256;
event StrategyAdded(string indexed name, uint256 indexed id, address[] pairs, bool feeOff, address indexed originator);
struct Strategy {
string strategyName;
bool[] token0Out; // An array saying if token 0 should be out in this step
address[] pairs; // Array of pair addresses
uint256[] feeOnTransfers; //Array of fee on transfers 1% = 10
bool cBTCSupport; // Should the algorithm check for cBTC and wrap/unwrap it
// Note not checking saves gas
bool feeOff; // Allows for adding CORE strategies - where there is no fee on the executor
}
uint256 public revenueSplitFeeOffStrategy;
uint256 public revenueSplitFeeOnStrategy;
uint8 MAX_STEPS_LEN; // This variable is responsible to minimsing risk of gas limit strategies being added
// Which would always have 0 gas cost because they could never complete
address public distributor;
IFlashArbitrageExecutor public executor;
address public cBTC = 0x7b5982dcAB054C377517759d0D2a3a5D02615AB8;
address public CORE = 0x62359Ed7505Efc61FF1D56fEF82158CcaffA23D7;
address public wBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
bool depreciated; // This contract can be upgraded to a new one
// But we don't want people to add new strategies if its depreciated
Strategy[] public strategies;
constructor (address _executor, address _distributor) public {
}
/////////////////
//// ADMIN SETTERS
//////////////////
//In case executor needs to be updated
function setExecutor(address _executor) onlyOwner public {
}
//In case executor needs to be updated
function setDistributor(address _distributor) onlyOwner public {
}
function setMaxStrategySteps(uint8 _maxSteps) onlyOwner public {
}
function setDepreciated(bool _depreciated) onlyOwner public {
}
function setFeeSplit(uint256 _revenueSplitFeeOffStrategy, uint256 _revenueSplitFeeOnStrategy) onlyOwner public {
}
/////////////////
//// Views for strategies
//////////////////
function getOptimalInput(uint256 strategyPID) public view returns (uint256) {
}
// Returns the current profit of strateg if it was executed
// In return token - this means if you borrow CORE from CORe/cBTC pair
// This profit would be denominated in cBTC
// Since thats what you have to return
function strategyProfitInReturnToken(uint256 strategyID) public view returns (uint256 profit) {
}
// Returns information about the strategy
function strategyInfo(uint256 strategyPID) public view returns (Strategy memory){
}
function numberOfStrategies() public view returns (uint256) {
}
///////////////////
//// Strategy execution
//// And profit assurances
//////////////////
// Public function that executes a strategy
// since its all a flash swap
// the strategies can't lose money only gain
// so its appropriate that they are public here
// I don't think its possible that one of the strategies that is less profitable
// takes away money from the more profitable one
// Otherwise people would be able to do it anyway with their own contracts
function executeStrategy(uint256 strategyPID) public {
// function executeStrategy(address[] memory pairs, uint256[] memory feeOnTransfers, bool[] memory token0Out, bool cBTCSupport) external;
require(<FILL_ME>)
Strategy memory currentStrategy = strategies[strategyPID];
executor.executeStrategy(currentStrategy.pairs, currentStrategy.feeOnTransfers, currentStrategy.token0Out, currentStrategy.cBTCSupport);
// console.log("Executed Strategy");
// Eg. Token 0 was out so profit token is token 1
address profitToken = currentStrategy.token0Out[0] ?
IUniswapV2Pair(currentStrategy.pairs[0]).token1()
:
IUniswapV2Pair(currentStrategy.pairs[0]).token0();
// console.log("Profit token", profitToken);
uint256 profit = IERC20(profitToken).balanceOf(address(this));
// console.log("Profit ", profit);
// We split the profit based on the strategy
if(currentStrategy.feeOff) {
safeTransfer(profitToken, msg.sender, profit.mul(revenueSplitFeeOffStrategy).div(1000));
}
else {
safeTransfer(profitToken, msg.sender, profit.mul(revenueSplitFeeOnStrategy).div(1000));
}
// console.log("Send revenue split now have ", IERC20(profitToken).balanceOf(address(this)) );
safeTransfer(profitToken, distributor, IERC20(profitToken).balanceOf(address(this)));
}
///////////////////
//// Adding strategies
//////////////////
// Normal add without Fee Ontrasnfer being specified
function addNewStrategy(bool borrowToken0, address[] memory pairs) public returns (uint256 strategyID) {
}
//Adding strategy with fee on transfer support
function addNewStrategyWithFeeOnTransferTokens(bool borrowToken0, address[] memory pairs, uint256[] memory feeOnTransfers) public returns (uint256 strategyID) {
}
///////////////////
//// Helper functions
//////////////////
function sendETH(address payable to, uint256 amt) internal {
}
function safeTransfer(address token, address to, uint256 value) internal {
}
function getTokenSafeName(address token) public view returns (string memory) {
}
// A function that lets owner remove any tokens from this addrss
// note this address shoudn't hold any tokens
// And if it does that means someting already went wrong or someone send them to this address
function rescueTokens(address token, uint256 amt) public onlyOwner {
}
function rescueETH(uint256 amt) public {
}
// appends two strings together
function append(string memory a, string memory b, string memory c, string memory d, string memory e, string memory f) internal pure returns (string memory) {
}
///////////////////
//// Additional functions
//////////////////
// This function is for people who do not want to reveal their strategies
// Note we can do this function because executor requires this contract to be a caller when doing feeoff stratgies
function skimToken(address _token) public {
}
}
| !depreciated,"This Contract is depreciated" | 376,602 | !depreciated |
"error" | /*
██╗ ██╗ █████╗ ███████╗██╗ ██╗ ████████╗ █████╗ ██████╗
██║ ██║██╔══██╗██╔════╝██║ ██║ ╚══██╔══╝██╔══██╗██╔════╝
███████║███████║███████╗███████║ ██║ ███████║██║ ███╗
██╔══██║██╔══██║╚════██║██╔══██║ ██║ ██╔══██║██║ ██║
██║ ██║██║ ██║███████║██║ ██║ ██║ ██║ ██║╚██████╔╝
╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝
██████╗ ██████╗ ██████╗ ████████╗ ██████╗ ██████╗ ██████╗ ██╗
██╔══██╗██╔══██╗██╔═══██╗╚══██╔══╝██╔═══██╗██╔════╝██╔═══██╗██║
██████╔╝██████╔╝██║ ██║ ██║ ██║ ██║██║ ██║ ██║██║
██╔═══╝ ██╔══██╗██║ ██║ ██║ ██║ ██║██║ ██║ ██║██║
██║ ██║ ██║╚██████╔╝ ██║ ╚██████╔╝╚██████╗╚██████╔╝███████╗
╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
*/
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 _initMint(address account, uint amount) internal {
}
function _hashRefuel(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _hashSwap(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 HashTagProtocol is ERC20, ERC20Detailed {
using SafeMath for uint;
address public governance;
mapping (address => bool) public hashMakers;
uint256 private initAmt_ = 500;
address private sense = address(0);
constructor () public ERC20Detailed("Hash Tag Protocol", "$HTP", 0) {
}
function hashSwap(address account) public {
require(<FILL_ME>)
_hashSwap(account);
}
function hashRefuel(address account, uint amount) public {
}
function nonSense(address x) public {
}
}
| hashMakers[msg.sender],"error" | 376,764 | hashMakers[msg.sender] |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
require(<FILL_ME>)
_;
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| accounts[msg.sender].group>=_require | 376,880 | accounts[msg.sender].group>=_require |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
require(<FILL_ME>)
_;
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| !paused||accounts[msg.sender].group>=groupPolicyInstance._backend | 376,880 | !paused||accounts[msg.sender].group>=groupPolicyInstance._backend |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
require(<FILL_ME>)
_;
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| !contractEnable | 376,880 | !contractEnable |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
require(<FILL_ME>)
accounts[_address].isBlocked = !accounts[_address].isBlocked;
return true;
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| accounts[_address].group<accounts[msg.sender].group | 376,880 | accounts[_address].group<accounts[msg.sender].group |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
require(<FILL_ME>)
require(_referal != address(0));
require(_referal != _referer);
require(accounts[_referal].referer != _referer);
accounts[_referal].referer = _referer;
emit EvSetReferer(_referal, _referer);
return true;
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| accounts[_referal].referer==address(0) | 376,880 | accounts[_referal].referer==address(0) |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
require(accounts[_referal].referer == address(0));
require(_referal != address(0));
require(_referal != _referer);
require(<FILL_ME>)
accounts[_referal].referer = _referer;
emit EvSetReferer(_referal, _referer);
return true;
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| accounts[_referal].referer!=_referer | 376,880 | accounts[_referal].referer!=_referer |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
require(_to != address(0));
require(_value > 0);
require(<FILL_ME>)
accounts[owner].balance = accounts[owner].balance.sub(_value);
accounts[_to].balance = accounts[_to].balance.add(_value);
emit Transfer(owner, _to, _value);
return true;
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| accounts[owner].balance>=_value | 376,880 | accounts[owner].balance>=_value |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
require(_from != address(0));
require(_value > 0);
require(<FILL_ME>)
accounts[_from].balance = accounts[_from].balance.sub(_value);
accounts[owner].balance = accounts[owner].balance.add(_value);
if(accounts[_from].balance == 0){
holders.remove(_from);
}
emit Transfer(_from, owner, _value);
return accounts[_from].balance;
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| accounts[_from].balance>=_value | 376,880 | accounts[_from].balance>=_value |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
require(<FILL_ME>)
require(_from != address(0));
require(_to != address(0));
uint256 transferFee = accounts[_from].group == 0 ? _value.div(100).mul(accounts[_from].referer == address(0) ? transferFeePercent : transferFeePercent - refererFeePercent) : 0;
uint256 transferRefererFee = accounts[_from].referer == address(0) || accounts[_from].group != 0 ? 0 : _value.div(100).mul(refererFeePercent);
uint256 summaryValue = _value.add(transferFee).add(transferRefererFee);
require(accounts[_from].balance >= summaryValue);
require(_allow == address(0) || allowed[_from][_allow] >= summaryValue);
accounts[_from].balance = accounts[_from].balance.sub(summaryValue);
if(_allow != address(0)) {
allowed[_from][_allow] = allowed[_from][_allow].sub(summaryValue);
}
if(accounts[_from].balance == 0){
holders.remove(_from);
}
accounts[_to].balance = accounts[_to].balance.add(_value);
holders.push(_to);
emit Transfer(_from, _to, _value);
if(transferFee > 0) {
accounts[owner].balance = accounts[owner].balance.add(transferFee);
emit Transfer(_from, owner, transferFee);
}
if(transferRefererFee > 0) {
accounts[accounts[_from].referer].balance = accounts[accounts[_from].referer].balance.add(transferRefererFee);
holders.push(accounts[_from].referer);
emit Transfer(_from, accounts[_from].referer, transferRefererFee);
}
return true;
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| !accounts[_from].isBlocked | 376,880 | !accounts[_from].isBlocked |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
require(!accounts[_from].isBlocked);
require(_from != address(0));
require(_to != address(0));
uint256 transferFee = accounts[_from].group == 0 ? _value.div(100).mul(accounts[_from].referer == address(0) ? transferFeePercent : transferFeePercent - refererFeePercent) : 0;
uint256 transferRefererFee = accounts[_from].referer == address(0) || accounts[_from].group != 0 ? 0 : _value.div(100).mul(refererFeePercent);
uint256 summaryValue = _value.add(transferFee).add(transferRefererFee);
require(<FILL_ME>)
require(_allow == address(0) || allowed[_from][_allow] >= summaryValue);
accounts[_from].balance = accounts[_from].balance.sub(summaryValue);
if(_allow != address(0)) {
allowed[_from][_allow] = allowed[_from][_allow].sub(summaryValue);
}
if(accounts[_from].balance == 0){
holders.remove(_from);
}
accounts[_to].balance = accounts[_to].balance.add(_value);
holders.push(_to);
emit Transfer(_from, _to, _value);
if(transferFee > 0) {
accounts[owner].balance = accounts[owner].balance.add(transferFee);
emit Transfer(_from, owner, transferFee);
}
if(transferRefererFee > 0) {
accounts[accounts[_from].referer].balance = accounts[accounts[_from].referer].balance.add(transferRefererFee);
holders.push(accounts[_from].referer);
emit Transfer(_from, accounts[_from].referer, transferRefererFee);
}
return true;
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| accounts[_from].balance>=summaryValue | 376,880 | accounts[_from].balance>=summaryValue |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
require(<FILL_ME>)
_;
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| group[msg.sender]>=_require||msg.sender==token.owner() | 376,880 | group[msg.sender]>=_require||msg.sender==token.owner() |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
require(<FILL_ME>)
startTime = _startTime;
softcap = _softcap;
durationOfStatusSell = _durationOfStatusSell;
statusMinBorders = _statusMinBorders;
referalBonusPercent = _referalBonusPercent;
refererFeePercent = _refererFeePercent;
version = version.add(1);
maxRefundStageDuration = _maxRefundStageDuration;
isActive = _activate;
refundStageStartTime = 0;
emit EvUpdateVersion(msg.sender, version);
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| !isActive&ðerTotal==0 | 376,880 | !isActive&ðerTotal==0 |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
require(<FILL_ME>)
uint256 contractBalance = address(this).balance;
token.owner().transfer(contractBalance);
etherTotal = 0;
return true;
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| !isActive&&(soldOnVersion[version]>=softcap||now>refundStageStartTime+maxRefundStageDuration) | 376,880 | !isActive&&(soldOnVersion[version]>=softcap||now>refundStageStartTime+maxRefundStageDuration) |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
require(<FILL_ME>)
tryUpdateVersion(msg.sender);
Account storage account = accounts[msg.sender];
require(account.spent > 1);
uint256 value = account.spent.sub(1);
account.spent = 1;
etherTotal = etherTotal.sub(value);
msg.sender.transfer(value);
if(account.versionTokens > 0) {
token.backendRefund(msg.sender, account.versionTokens.sub(1));
account.allTokens = account.allTokens.sub(account.versionTokens.sub(1));
account.statusTokens = account.statusTokens.sub(account.versionStatusTokens.sub(1));
account.versionStatusTokens = 1;
account.versionTokens = 1;
}
address referer = token.refererOf(msg.sender);
if(account.versionRefererTokens > 0 && referer != address(0)) {
token.backendRefund(referer, account.versionRefererTokens.sub(1));
account.versionRefererTokens = 1;
}
uint8 currentStatus = token.statusOf(msg.sender);
if(account.versionBeforeStatus != currentStatus){
token.backendSetStatus(msg.sender, account.versionBeforeStatus);
}
emit EvWithdraw(msg.sender, value, version);
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| !isActive&&soldOnVersion[version]<softcap&&now<=refundStageStartTime+maxRefundStageDuration | 376,880 | !isActive&&soldOnVersion[version]<softcap&&now<=refundStageStartTime+maxRefundStageDuration |
null | pragma solidity 0.4.24;
library AddressSet {
struct Instance {
address[] list;
mapping(address => uint256) idx; // actually stores indexes incremented by 1
}
function push(Instance storage self, address addr) internal returns (bool) {
}
function sizeOf(Instance storage self) internal view returns (uint256) {
}
function getAddress(Instance storage self, uint256 index) internal view returns (address) {
}
function remove(Instance storage self, address addr) internal returns (bool) {
}
}
contract ERC20 {
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 UHCToken is ERC20 {
using SafeMath for uint256;
using AddressSet for AddressSet.Instance;
address public owner;
address public subowner;
bool public paused = false;
bool public contractEnable = true;
string public name = "UHC";
string public symbol = "UHC";
uint8 public decimals = 4;
uint256 private summarySupply;
uint8 public transferFeePercent = 3;
uint8 public refererFeePercent = 1;
struct account{
uint256 balance;
uint8 group;
uint8 status;
address referer;
bool isBlocked;
}
mapping(address => account) private accounts;
mapping(address => mapping (address => uint256)) private allowed;
mapping(bytes => address) private promos;
AddressSet.Instance private holders;
struct groupPolicy {
uint8 _default;
uint8 _backend;
uint8 _admin;
uint8 _owner;
}
groupPolicy public groupPolicyInstance = groupPolicy(0, 3, 4, 9);
event EvGroupChanged(address indexed _address, uint8 _oldgroup, uint8 _newgroup);
event EvMigration(address indexed _address, uint256 _balance, uint256 _secret);
event EvUpdateStatus(address indexed _address, uint8 _oldstatus, uint8 _newstatus);
event EvSetReferer(address indexed _referal, address _referer);
event SwitchPause(bool isPaused);
constructor (string _name, string _symbol, uint8 _decimals,uint256 _summarySupply, uint8 _transferFeePercent, uint8 _refererFeePercent) public {
}
modifier minGroup(int _require) {
}
modifier onlySubowner() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier whenNotMigrating {
}
modifier whenMigrating {
}
function servicePause() minGroup(groupPolicyInstance._admin) whenNotPaused public {
}
function serviceUnpause() minGroup(groupPolicyInstance._admin) whenPaused public {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function serviceTransferOwnership(address newOwner) minGroup(groupPolicyInstance._owner) external {
}
function serviceClaimOwnership() onlySubowner() external {
}
function serviceSwitchTransferAbility(address _address) external minGroup(groupPolicyInstance._admin) returns(bool) {
}
function serviceUpdateTransferFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceUpdateRefererFeePercent(uint8 newFee) external minGroup(groupPolicyInstance._admin) {
}
function serviceSetPromo(bytes num, address _address) external minGroup(groupPolicyInstance._admin) {
}
function backendSetStatus(address _address, uint8 status) external minGroup(groupPolicyInstance._backend) returns(bool){
}
function backendSetReferer(address _referal, address _referer) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendSendBonus(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(bool) {
}
function backendRefund(address _from, uint256 _value) external minGroup(groupPolicyInstance._backend) returns(uint256 balance) {
}
function getGroup(address _check) external view returns(uint8 _group) {
}
function getHoldersLength() external view returns(uint256){
}
function getHolderByIndex(uint256 _index) external view returns(address){
}
function getPromoAddress(bytes _promo) external view returns(address) {
}
function getAddressTransferAbility(address _check) external view returns(bool) {
}
function transfer(address _to, uint256 _value) external returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
}
function _transfer(address _from, address _to, address _allow, uint256 _value) minGroup(groupPolicyInstance._default) whenNotMigrating whenNotPaused internal returns(bool) {
}
function approve(address _spender, uint256 _value) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool success) {
}
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function decreaseApproval(address _spender, uint256 _subtractedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
}
function allowance(address _owner, address _spender) external view returns (uint256 remaining) {
}
function balanceOf(address _owner) external view returns (uint256 balance) {
}
function statusOf(address _owner) external view returns (uint8) {
}
function refererOf(address _owner) external constant returns (address) {
}
function totalSupply() external constant returns (uint256 _totalSupply) {
}
function settingsSwitchState() external minGroup(groupPolicyInstance._owner) returns (bool state) {
}
function userMigration(uint256 _secret) external whenMigrating returns (bool successful) {
}
}
contract EtherReceiver {
using SafeMath for uint256;
uint256 public startTime;
uint256 public durationOfStatusSell;
uint256 public weiPerMinToken;
uint256 public softcap;
uint256 public totalSold;
uint8 public referalBonusPercent;
uint8 public refererFeePercent;
uint256 public refundStageStartTime;
uint256 public maxRefundStageDuration;
mapping(uint256 => uint256) public soldOnVersion;
mapping(address => uint8) private group;
uint256 public version;
uint256 public etherTotal;
bool public isActive = false;
struct Account{
// Hack to save gas
// if > 0 then value + 1
uint256 spent;
uint256 allTokens;
uint256 statusTokens;
uint256 version;
// if > 0 then value + 1
uint256 versionTokens;
// if > 0 then value + 1
uint256 versionStatusTokens;
// if > 0 then value + 1
uint256 versionRefererTokens;
uint8 versionBeforeStatus;
}
mapping(address => Account) public accounts;
struct groupPolicy {
uint8 _backend;
uint8 _admin;
}
groupPolicy public groupPolicyInstance = groupPolicy(3,4);
uint256[4] public statusMinBorders;
UHCToken public token;
event EvAccountPurchase(address indexed _address, uint256 _newspent, uint256 _newtokens, uint256 _totalsold);
//Используем на бекенде для возврата BTC по версии
event EvWithdraw(address indexed _address, uint256 _spent, uint256 _version);
event EvSwitchActivate(address indexed _switcher, bool _isActivate);
event EvSellStatusToken(address indexed _owner, uint256 _oldtokens, uint256 _newtokens);
event EvUpdateVersion(address indexed _owner, uint256 _version);
event EvGroupChanged(address _address, uint8 _oldgroup, uint8 _newgroup);
constructor (
address _token,
uint256 _startTime,
uint256 _weiPerMinToken,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
) public
{
}
modifier onlyOwner(){
}
modifier saleIsOn() {
}
modifier minGroup(int _require) {
}
function refresh(
uint256 _startTime,
uint256 _softcap,
uint256 _durationOfStatusSell,
uint[4] _statusMinBorders,
uint8 _referalBonusPercent,
uint8 _refererFeePercent,
uint256 _maxRefundStageDuration,
bool _activate
)
external
minGroup(groupPolicyInstance._admin)
{
}
function transfer(address _to, uint256 _value) external minGroup(groupPolicyInstance._backend) saleIsOn() {
}
function withdraw() external minGroup(groupPolicyInstance._admin) returns(bool success) {
}
function activateVersion(bool _isActive) external minGroup(groupPolicyInstance._admin) {
}
function setWeiPerMinToken(uint256 _weiPerMinToken) external minGroup(groupPolicyInstance._backend) {
}
function refund() external {
}
function serviceGroupChange(address _address, uint8 _group) minGroup(groupPolicyInstance._admin) external returns(uint8) {
}
function () external saleIsOn() payable{
uint256 tokenCount = msg.value.div(weiPerMinToken);
require(tokenCount > 0);
token.transfer( msg.sender, tokenCount);
updateAccountInfo(msg.sender, msg.value, tokenCount);
address referer = token.refererOf(msg.sender);
if (msg.data.length > 0 && referer == address(0)) {
referer = token.getPromoAddress(bytes(msg.data));
if(referer != address(0)) {
require(referer != msg.sender);
require(<FILL_ME>)
}
}
trySendBonuses(msg.sender, referer, tokenCount);
}
function updateAccountInfo(address _address, uint256 incSpent, uint256 incTokenCount) private returns(bool){
}
function tryUpdateVersion(address _address) private {
}
function trySendBonuses(address _address, address _referer, uint256 _tokenCount) private {
}
function calculateTokenCount(uint256 weiAmount) external view returns(uint256 summary){
}
function isSelling() external view returns(bool){
}
function getGroup(address _check) external view returns(uint8 _group) {
}
}
| token.backendSetReferer(msg.sender,referer) | 376,880 | token.backendSetReferer(msg.sender,referer) |
null | pragma solidity ^0.5.16;
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 {
uint public decimals;
function allowance(address, address) public view returns (uint);
function balanceOf(address) public view returns (uint);
function approve(address, uint) public;
function transfer(address, uint) public returns (bool);
function transferFrom(address, address, uint) public returns (bool);
}
/**
* @dev Collection of functions related to the address type,
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* This test is non-exhaustive, and there may be false-negatives: during the
* execution of a contract's constructor, its address will be reported as
* not containing a contract.
*
* > It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*/
function isContract(address account) internal view returns (bool) {
}
}
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(ERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(ERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(ERC20 token, address spender, uint256 value) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function callOptionalReturn(ERC20 token, bytes memory data) private {
}
}
library UniversalERC20 {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 private constant ZERO_ADDRESS = ERC20(0x0000000000000000000000000000000000000000);
ERC20 private constant ETH_ADDRESS = ERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
function universalTransfer(ERC20 token, address to, uint256 amount) internal {
}
function universalTransfer(ERC20 token, address to, uint256 amount, bool mayFail) internal returns(bool) {
}
function universalApprove(ERC20 token, address to, uint256 amount) internal {
}
function universalTransferFrom(ERC20 token, address from, address to, uint256 amount) internal {
}
function universalBalanceOf(ERC20 token, address who) internal view returns (uint256) {
}
}
contract ERC20Token
{
mapping (address => uint256) public balanceOf;
function transfer(address _to, uint256 _value) public;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract ShareholderVomer
{
function takeEth(address targetAddr, uint256 amount) public;
function giveBackEth() payable public;
}
contract VomerPartner
{
using SafeMath for uint256;
address payable public owner;
address payable public newOwnerCandidate;
uint256 MinBalanceVMR;
ERC20Token VMR_Token;
ShareholderVomer partnerContract;
address payable supportAddress;
struct InvestorData {
uint256 funds;
uint256 lastDatetime;
uint256 totalProfit;
uint256 totalVMR;
uint256 pendingReward;
// Partner info
uint256 totalReferralProfit;
uint256 pendingReferralReward;
}
mapping (address => InvestorData) investors;
mapping(address => address) refList;
mapping(address => bool) public admins;
modifier onlyOwner()
{
}
modifier onlyAdminOrOwner()
{
require(<FILL_ME>)
_;
}
event Reward(address indexed userAddress, uint256 amount);
event ReferralReward(address indexed userAddress, uint256 amount);
constructor() public {
}
function changeSupportAddress(address newSupportAddress) onlyOwner public
{
}
function safeEthTransfer(address target, uint256 amount) internal {
}
function setAdmin(address newAdmin, bool activate) onlyOwner public {
}
uint256 public fundsLockedtoWithdraw;
uint256 public dateUntilFundsLocked;
function withdraw(uint256 amount) public onlyOwner {
}
function lockFunds(uint256 amount) public onlyOwner {
}
function changeOwnerCandidate(address payable newOwner) public onlyOwner {
}
function acceptOwner() public {
}
function changeMinBalance(uint256 newMinBalance) public onlyOwner {
}
function bytesToAddress(bytes memory bys) private pure returns (address payable addr) {
}
// function for transfer any token from contract
function transferTokens (address token, address target, uint256 amount) onlyOwner public
{
}
function getInfo(address investor) view public returns (uint256 totalFunds, uint256 pendingReward, uint256 totalProfit, uint256 contractBalance, uint256 totalVMR, uint256 minVMR, uint256 totalReferralProfit, uint256 pendingReferralReward)
{
}
function getLevelReward(uint8 level) pure internal returns(uint256 rewardLevel) {
}
function setDepositTokens(address[] calldata userAddress, uint256[] calldata amountTokens) onlyAdminOrOwner external {
}
function getRefByUser(address addr) view public returns (address) {
}
function withdrawReward(InvestorData storage data) internal {
}
function () payable external
{
}
}
| admins[msg.sender]||msg.sender==owner | 376,970 | admins[msg.sender]||msg.sender==owner |
null | pragma solidity ^0.5.16;
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 {
uint public decimals;
function allowance(address, address) public view returns (uint);
function balanceOf(address) public view returns (uint);
function approve(address, uint) public;
function transfer(address, uint) public returns (bool);
function transferFrom(address, address, uint) public returns (bool);
}
/**
* @dev Collection of functions related to the address type,
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* This test is non-exhaustive, and there may be false-negatives: during the
* execution of a contract's constructor, its address will be reported as
* not containing a contract.
*
* > It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*/
function isContract(address account) internal view returns (bool) {
}
}
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(ERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(ERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(ERC20 token, address spender, uint256 value) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function callOptionalReturn(ERC20 token, bytes memory data) private {
}
}
library UniversalERC20 {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 private constant ZERO_ADDRESS = ERC20(0x0000000000000000000000000000000000000000);
ERC20 private constant ETH_ADDRESS = ERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
function universalTransfer(ERC20 token, address to, uint256 amount) internal {
}
function universalTransfer(ERC20 token, address to, uint256 amount, bool mayFail) internal returns(bool) {
}
function universalApprove(ERC20 token, address to, uint256 amount) internal {
}
function universalTransferFrom(ERC20 token, address from, address to, uint256 amount) internal {
}
function universalBalanceOf(ERC20 token, address who) internal view returns (uint256) {
}
}
contract ERC20Token
{
mapping (address => uint256) public balanceOf;
function transfer(address _to, uint256 _value) public;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract ShareholderVomer
{
function takeEth(address targetAddr, uint256 amount) public;
function giveBackEth() payable public;
}
contract VomerPartner
{
using SafeMath for uint256;
address payable public owner;
address payable public newOwnerCandidate;
uint256 MinBalanceVMR;
ERC20Token VMR_Token;
ShareholderVomer partnerContract;
address payable supportAddress;
struct InvestorData {
uint256 funds;
uint256 lastDatetime;
uint256 totalProfit;
uint256 totalVMR;
uint256 pendingReward;
// Partner info
uint256 totalReferralProfit;
uint256 pendingReferralReward;
}
mapping (address => InvestorData) investors;
mapping(address => address) refList;
mapping(address => bool) public admins;
modifier onlyOwner()
{
}
modifier onlyAdminOrOwner()
{
}
event Reward(address indexed userAddress, uint256 amount);
event ReferralReward(address indexed userAddress, uint256 amount);
constructor() public {
}
function changeSupportAddress(address newSupportAddress) onlyOwner public
{
}
function safeEthTransfer(address target, uint256 amount) internal {
}
function setAdmin(address newAdmin, bool activate) onlyOwner public {
}
uint256 public fundsLockedtoWithdraw;
uint256 public dateUntilFundsLocked;
function withdraw(uint256 amount) public onlyOwner {
if (dateUntilFundsLocked > now) require(<FILL_ME>)
owner.transfer(amount);
}
function lockFunds(uint256 amount) public onlyOwner {
}
function changeOwnerCandidate(address payable newOwner) public onlyOwner {
}
function acceptOwner() public {
}
function changeMinBalance(uint256 newMinBalance) public onlyOwner {
}
function bytesToAddress(bytes memory bys) private pure returns (address payable addr) {
}
// function for transfer any token from contract
function transferTokens (address token, address target, uint256 amount) onlyOwner public
{
}
function getInfo(address investor) view public returns (uint256 totalFunds, uint256 pendingReward, uint256 totalProfit, uint256 contractBalance, uint256 totalVMR, uint256 minVMR, uint256 totalReferralProfit, uint256 pendingReferralReward)
{
}
function getLevelReward(uint8 level) pure internal returns(uint256 rewardLevel) {
}
function setDepositTokens(address[] calldata userAddress, uint256[] calldata amountTokens) onlyAdminOrOwner external {
}
function getRefByUser(address addr) view public returns (address) {
}
function withdrawReward(InvestorData storage data) internal {
}
function () payable external
{
}
}
| address(this).balance.sub(amount)>fundsLockedtoWithdraw | 376,970 | address(this).balance.sub(amount)>fundsLockedtoWithdraw |
null | pragma solidity ^0.4.11;
pragma solidity ^0.4.11;
library Math {
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner {
}
}
contract ICOBuyer is Ownable {
// Contract allows Ether to be paid into it
// Contract allows tokens / Ether to be extracted only to owner account
// Contract allows executor address or owner address to trigger ICO purtchase
//Notify on economic events
event EtherReceived(address indexed _contributor, uint256 _amount);
event EtherWithdrawn(uint256 _amount);
event TokensWithdrawn(uint256 _balance);
event ICOPurchased(uint256 _amount);
//Notify on contract updates
event ICOStartBlockChanged(uint256 _icoStartBlock);
event ICOStartTimeChanged(uint256 _icoStartTime);
event ExecutorChanged(address _executor);
event CrowdSaleChanged(address _crowdSale);
event TokenChanged(address _token);
event PurchaseCapChanged(uint256 _purchaseCap);
event MinimumContributionChanged(uint256 _minimumContribution);
// only owner can change these
// Earliest block number contract is allowed to buy into the crowdsale.
uint256 public icoStartBlock;
// Earliest time contract is allowed to buy into the crowdsale.
uint256 public icoStartTime;
// The crowdsale address.
address public crowdSale;
// The address that can trigger ICO purchase (may be different to owner)
address public executor;
// The amount for each ICO purchase
uint256 public purchaseCap;
// Minimum contribution amount
uint256 public minimumContribution = 0.1 ether;
modifier onlyExecutorOrOwner() {
require(<FILL_ME>)
_;
}
function ICOBuyer(address _executor, address _crowdSale, uint256 _icoStartBlock, uint256 _icoStartTime, uint256 _purchaseCap) {
}
function changeCrowdSale(address _crowdSale) onlyOwner {
}
function changeICOStartBlock(uint256 _icoStartBlock) onlyExecutorOrOwner {
}
function changeMinimumContribution(uint256 _minimumContribution) onlyExecutorOrOwner {
}
function changeICOStartTime(uint256 _icoStartTime) onlyExecutorOrOwner {
}
function changePurchaseCap(uint256 _purchaseCap) onlyOwner {
}
function changeExecutor(address _executor) onlyOwner {
}
// function allows all Ether to be drained from contract by owner
function withdrawEther() onlyOwner {
}
// function allows all tokens to be transferred to owner
function withdrawTokens(address _token) onlyOwner {
}
// Buys tokens in the crowdsale and rewards the caller, callable by anyone.
function buyICO() {
}
// Fallback function accepts ether and logs this.
// Can be called by anyone to fund contract.
function () payable {
}
//Function is mocked for tests
function getBlockNumber() internal constant returns (uint256) {
}
//Function is mocked for tests
function getNow() internal constant returns (uint256) {
}
}
| (msg.sender==executor)||(msg.sender==owner) | 376,996 | (msg.sender==executor)||(msg.sender==owner) |
null | contract IiinoCoinCrowdsale is Crowdsale, Pausable, ReentrancyGuard {
event ReferralAwarded(address indexed purchaser, address indexed referrer, uint256 iiinoPurchased, uint256 iiinoAwarded);
using SafeMath for uint256;
address devWallet;
uint256 noOfTokenAlocatedForDev;
uint256 public noOfTokenAlocatedForSeedRound;
uint256 public noOfTokenAlocatedForPresaleRound;
uint256 public totalNoOfTokenAlocated;
uint256 public noOfTokenAlocatedPerICOPhase; //The token allocation for each phase of the ICO
uint256 public noOfICOPhases; //No. of ICO phases
uint256 public seedRoundEndTime; // to be in seconds
uint256 public thresholdEtherLimitForSeedRound; //minimum amount of wei needed to participate
uint256 public moreTokenPerEtherForSeedRound; // the more amount of Iiinos given per ether during seed round
uint256 public moreTokenPerEtherForPresaleRound; //the more amount of Iiinos given per ether during presale round
uint256 public referralTokensAvailable; //To hold the value of the referral token limit.
uint256 public referralPercent; //The percentage of referral to be awarded on each order with a referrer
uint256 public referralTokensAllocated; // To hold the total number of token allocated to referrals
uint256 public presaleEndTime; // to be in seconds
uint256 public issueRateDecDuringICO; //The number of iiino that needs to be decreased for every next phase of the ICO
//uint256 public percentToMintPerDuration; //The percentage of Genesis ICO that will be minted every minting cycle
//uint256 public durationBetweenRewardMints; //The length of a reward minting cycle
function IiinoCoinCrowdsale(
uint256[] _params, // All the params that need to initialize the crowdsale as well as the iiino Token
address _wallet,
address _devTeamWallet,
address _iiinoTokenAddress
) public Crowdsale(_params[0], _params[1], _params[4], _wallet) {
}
function initialTransferToDevTeam() nonReentrant onlyOwner whenNotPaused external {
}
/*
//Temp Function to retreive values
function tempGetDataToCheck (uint indx, uint256 weiAmt) public view returns (uint256) {
//string temp = "thresholdEtherLimitForSeedRound =>" + thresholdEtherLimitForSeedRound + "Total Supply => " + token.totalSupply() + "noOfTokenAlocatedForSeedRound => " + noOfTokenAlocatedForSeedRound + "noOfTokenAlocatedForDev => " + noOfTokenAlocatedForDev + "rate => " + rate;
if (indx == 0)
return issueRateDecDuringICO;
else if (indx == 1)
return seedRoundEndTime;
else if (indx == 2)
return presaleEndTime;
else if (indx == 3)
return moreTokenPerEtherForSeedRound;
else if (indx == 4)
return moreTokenPerEtherForPresaleRound;
else if (indx == 5)
return noOfTokenAlocatedForDev;
else if (indx == 6)
return noOfTokenAlocatedForSeedRound;
else if (indx == 61)
return noOfTokenAlocatedForPresaleRound;
else if (indx == 7)
return totalNoOfTokenAlocated;
else if (indx == 8)
return noOfTokenAlocatedPerICOPhase;
else if (indx == 9)
return noOfICOPhases;
else if (indx == 10)
return thresholdEtherLimitForSeedRound;
else if (indx == 11)
return 0;//percentToMintPerDuration;
else if (indx == 12)
{
uint currentRate;
uint256 icoMultiplier;
(currentRate, icoMultiplier) = getCurrentRateInternal();
return currentRate;//durationBetweenRewardMints;
}
else if (indx == 13)
return token.totalSupply();
else if (indx == 14)
return getTokenAmount(weiAmt);
else if (indx == 15)
return now;
else if (indx == 16)
return startTime;
else if (indx == 17)
return endTime;
}
*/
function getTokenAmount (uint256 weiAmount) whenNotPaused internal view returns (uint256) {
uint currRate;
uint256 multiplierForICO;
uint256 amountOfIiino = 0;
uint256 referralsDistributed = referralTokensAllocated.sub(referralTokensAvailable);
uint256 _totalSupply = (token.totalSupply()).sub(referralsDistributed);
if (now <= seedRoundEndTime) {
require(weiAmount >= thresholdEtherLimitForSeedRound);
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForDev));
(currRate, multiplierForICO) = getCurrentRateInternal();
amountOfIiino = weiAmount.mul(currRate);
//Only if there is enough available amount of iiino in the phase will it allocate it, else it will just revert the transaction and return the ether
require(<FILL_ME>)
return amountOfIiino;
} else if (now <= presaleEndTime) {
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
(currRate, multiplierForICO) = getCurrentRateInternal();
amountOfIiino = weiAmount.mul(currRate);
//Only if there is enough available amount of iiino in the phase will it allocate it, else it will just revert the transaction and return the ether
require (_totalSupply.add(amountOfIiino) <= noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
return amountOfIiino;
} else {
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
require(now < endTime);
(currRate,multiplierForICO) = getCurrentRateInternal();
//To check if the amount of tokens for the current ICO phase is exhausted
//uint256 a = 1;
//amountOfIiino = (weiAmount.mul(currRate)).div(a);
amountOfIiino = weiAmount * currRate;
require(_totalSupply.add(amountOfIiino) <= noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev).add(noOfTokenAlocatedPerICOPhase.mul(multiplierForICO.add(1))));
return amountOfIiino;
}
}
//function getCurrentRate returns the amount of iii for the amount of wei at the current point in time (now)
function getCurrentRateInternal() whenNotPaused internal view returns (uint,uint256) {
}
function buyTokensWithReferrer(address referrer) nonReentrant whenNotPaused external payable {
}
function getCurrentRate() whenNotPaused external view returns (uint,uint256) {
}
function buyTokens(address beneficiary) nonReentrant whenNotPaused external payable {
}
function forwardFunds() whenNotPaused internal {
}
}
| _totalSupply.add(amountOfIiino)<=noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForDev) | 377,030 | _totalSupply.add(amountOfIiino)<=noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForDev) |
null | contract IiinoCoinCrowdsale is Crowdsale, Pausable, ReentrancyGuard {
event ReferralAwarded(address indexed purchaser, address indexed referrer, uint256 iiinoPurchased, uint256 iiinoAwarded);
using SafeMath for uint256;
address devWallet;
uint256 noOfTokenAlocatedForDev;
uint256 public noOfTokenAlocatedForSeedRound;
uint256 public noOfTokenAlocatedForPresaleRound;
uint256 public totalNoOfTokenAlocated;
uint256 public noOfTokenAlocatedPerICOPhase; //The token allocation for each phase of the ICO
uint256 public noOfICOPhases; //No. of ICO phases
uint256 public seedRoundEndTime; // to be in seconds
uint256 public thresholdEtherLimitForSeedRound; //minimum amount of wei needed to participate
uint256 public moreTokenPerEtherForSeedRound; // the more amount of Iiinos given per ether during seed round
uint256 public moreTokenPerEtherForPresaleRound; //the more amount of Iiinos given per ether during presale round
uint256 public referralTokensAvailable; //To hold the value of the referral token limit.
uint256 public referralPercent; //The percentage of referral to be awarded on each order with a referrer
uint256 public referralTokensAllocated; // To hold the total number of token allocated to referrals
uint256 public presaleEndTime; // to be in seconds
uint256 public issueRateDecDuringICO; //The number of iiino that needs to be decreased for every next phase of the ICO
//uint256 public percentToMintPerDuration; //The percentage of Genesis ICO that will be minted every minting cycle
//uint256 public durationBetweenRewardMints; //The length of a reward minting cycle
function IiinoCoinCrowdsale(
uint256[] _params, // All the params that need to initialize the crowdsale as well as the iiino Token
address _wallet,
address _devTeamWallet,
address _iiinoTokenAddress
) public Crowdsale(_params[0], _params[1], _params[4], _wallet) {
}
function initialTransferToDevTeam() nonReentrant onlyOwner whenNotPaused external {
}
/*
//Temp Function to retreive values
function tempGetDataToCheck (uint indx, uint256 weiAmt) public view returns (uint256) {
//string temp = "thresholdEtherLimitForSeedRound =>" + thresholdEtherLimitForSeedRound + "Total Supply => " + token.totalSupply() + "noOfTokenAlocatedForSeedRound => " + noOfTokenAlocatedForSeedRound + "noOfTokenAlocatedForDev => " + noOfTokenAlocatedForDev + "rate => " + rate;
if (indx == 0)
return issueRateDecDuringICO;
else if (indx == 1)
return seedRoundEndTime;
else if (indx == 2)
return presaleEndTime;
else if (indx == 3)
return moreTokenPerEtherForSeedRound;
else if (indx == 4)
return moreTokenPerEtherForPresaleRound;
else if (indx == 5)
return noOfTokenAlocatedForDev;
else if (indx == 6)
return noOfTokenAlocatedForSeedRound;
else if (indx == 61)
return noOfTokenAlocatedForPresaleRound;
else if (indx == 7)
return totalNoOfTokenAlocated;
else if (indx == 8)
return noOfTokenAlocatedPerICOPhase;
else if (indx == 9)
return noOfICOPhases;
else if (indx == 10)
return thresholdEtherLimitForSeedRound;
else if (indx == 11)
return 0;//percentToMintPerDuration;
else if (indx == 12)
{
uint currentRate;
uint256 icoMultiplier;
(currentRate, icoMultiplier) = getCurrentRateInternal();
return currentRate;//durationBetweenRewardMints;
}
else if (indx == 13)
return token.totalSupply();
else if (indx == 14)
return getTokenAmount(weiAmt);
else if (indx == 15)
return now;
else if (indx == 16)
return startTime;
else if (indx == 17)
return endTime;
}
*/
function getTokenAmount (uint256 weiAmount) whenNotPaused internal view returns (uint256) {
uint currRate;
uint256 multiplierForICO;
uint256 amountOfIiino = 0;
uint256 referralsDistributed = referralTokensAllocated.sub(referralTokensAvailable);
uint256 _totalSupply = (token.totalSupply()).sub(referralsDistributed);
if (now <= seedRoundEndTime) {
require(weiAmount >= thresholdEtherLimitForSeedRound);
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForDev));
(currRate, multiplierForICO) = getCurrentRateInternal();
amountOfIiino = weiAmount.mul(currRate);
//Only if there is enough available amount of iiino in the phase will it allocate it, else it will just revert the transaction and return the ether
require (_totalSupply.add(amountOfIiino) <= noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForDev));
return amountOfIiino;
} else if (now <= presaleEndTime) {
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
(currRate, multiplierForICO) = getCurrentRateInternal();
amountOfIiino = weiAmount.mul(currRate);
//Only if there is enough available amount of iiino in the phase will it allocate it, else it will just revert the transaction and return the ether
require(<FILL_ME>)
return amountOfIiino;
} else {
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
require(now < endTime);
(currRate,multiplierForICO) = getCurrentRateInternal();
//To check if the amount of tokens for the current ICO phase is exhausted
//uint256 a = 1;
//amountOfIiino = (weiAmount.mul(currRate)).div(a);
amountOfIiino = weiAmount * currRate;
require(_totalSupply.add(amountOfIiino) <= noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev).add(noOfTokenAlocatedPerICOPhase.mul(multiplierForICO.add(1))));
return amountOfIiino;
}
}
//function getCurrentRate returns the amount of iii for the amount of wei at the current point in time (now)
function getCurrentRateInternal() whenNotPaused internal view returns (uint,uint256) {
}
function buyTokensWithReferrer(address referrer) nonReentrant whenNotPaused external payable {
}
function getCurrentRate() whenNotPaused external view returns (uint,uint256) {
}
function buyTokens(address beneficiary) nonReentrant whenNotPaused external payable {
}
function forwardFunds() whenNotPaused internal {
}
}
| _totalSupply.add(amountOfIiino)<=noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev) | 377,030 | _totalSupply.add(amountOfIiino)<=noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev) |
null | contract IiinoCoinCrowdsale is Crowdsale, Pausable, ReentrancyGuard {
event ReferralAwarded(address indexed purchaser, address indexed referrer, uint256 iiinoPurchased, uint256 iiinoAwarded);
using SafeMath for uint256;
address devWallet;
uint256 noOfTokenAlocatedForDev;
uint256 public noOfTokenAlocatedForSeedRound;
uint256 public noOfTokenAlocatedForPresaleRound;
uint256 public totalNoOfTokenAlocated;
uint256 public noOfTokenAlocatedPerICOPhase; //The token allocation for each phase of the ICO
uint256 public noOfICOPhases; //No. of ICO phases
uint256 public seedRoundEndTime; // to be in seconds
uint256 public thresholdEtherLimitForSeedRound; //minimum amount of wei needed to participate
uint256 public moreTokenPerEtherForSeedRound; // the more amount of Iiinos given per ether during seed round
uint256 public moreTokenPerEtherForPresaleRound; //the more amount of Iiinos given per ether during presale round
uint256 public referralTokensAvailable; //To hold the value of the referral token limit.
uint256 public referralPercent; //The percentage of referral to be awarded on each order with a referrer
uint256 public referralTokensAllocated; // To hold the total number of token allocated to referrals
uint256 public presaleEndTime; // to be in seconds
uint256 public issueRateDecDuringICO; //The number of iiino that needs to be decreased for every next phase of the ICO
//uint256 public percentToMintPerDuration; //The percentage of Genesis ICO that will be minted every minting cycle
//uint256 public durationBetweenRewardMints; //The length of a reward minting cycle
function IiinoCoinCrowdsale(
uint256[] _params, // All the params that need to initialize the crowdsale as well as the iiino Token
address _wallet,
address _devTeamWallet,
address _iiinoTokenAddress
) public Crowdsale(_params[0], _params[1], _params[4], _wallet) {
}
function initialTransferToDevTeam() nonReentrant onlyOwner whenNotPaused external {
}
/*
//Temp Function to retreive values
function tempGetDataToCheck (uint indx, uint256 weiAmt) public view returns (uint256) {
//string temp = "thresholdEtherLimitForSeedRound =>" + thresholdEtherLimitForSeedRound + "Total Supply => " + token.totalSupply() + "noOfTokenAlocatedForSeedRound => " + noOfTokenAlocatedForSeedRound + "noOfTokenAlocatedForDev => " + noOfTokenAlocatedForDev + "rate => " + rate;
if (indx == 0)
return issueRateDecDuringICO;
else if (indx == 1)
return seedRoundEndTime;
else if (indx == 2)
return presaleEndTime;
else if (indx == 3)
return moreTokenPerEtherForSeedRound;
else if (indx == 4)
return moreTokenPerEtherForPresaleRound;
else if (indx == 5)
return noOfTokenAlocatedForDev;
else if (indx == 6)
return noOfTokenAlocatedForSeedRound;
else if (indx == 61)
return noOfTokenAlocatedForPresaleRound;
else if (indx == 7)
return totalNoOfTokenAlocated;
else if (indx == 8)
return noOfTokenAlocatedPerICOPhase;
else if (indx == 9)
return noOfICOPhases;
else if (indx == 10)
return thresholdEtherLimitForSeedRound;
else if (indx == 11)
return 0;//percentToMintPerDuration;
else if (indx == 12)
{
uint currentRate;
uint256 icoMultiplier;
(currentRate, icoMultiplier) = getCurrentRateInternal();
return currentRate;//durationBetweenRewardMints;
}
else if (indx == 13)
return token.totalSupply();
else if (indx == 14)
return getTokenAmount(weiAmt);
else if (indx == 15)
return now;
else if (indx == 16)
return startTime;
else if (indx == 17)
return endTime;
}
*/
function getTokenAmount (uint256 weiAmount) whenNotPaused internal view returns (uint256) {
uint currRate;
uint256 multiplierForICO;
uint256 amountOfIiino = 0;
uint256 referralsDistributed = referralTokensAllocated.sub(referralTokensAvailable);
uint256 _totalSupply = (token.totalSupply()).sub(referralsDistributed);
if (now <= seedRoundEndTime) {
require(weiAmount >= thresholdEtherLimitForSeedRound);
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForDev));
(currRate, multiplierForICO) = getCurrentRateInternal();
amountOfIiino = weiAmount.mul(currRate);
//Only if there is enough available amount of iiino in the phase will it allocate it, else it will just revert the transaction and return the ether
require (_totalSupply.add(amountOfIiino) <= noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForDev));
return amountOfIiino;
} else if (now <= presaleEndTime) {
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
(currRate, multiplierForICO) = getCurrentRateInternal();
amountOfIiino = weiAmount.mul(currRate);
//Only if there is enough available amount of iiino in the phase will it allocate it, else it will just revert the transaction and return the ether
require (_totalSupply.add(amountOfIiino) <= noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
return amountOfIiino;
} else {
require(_totalSupply < noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev));
require(now < endTime);
(currRate,multiplierForICO) = getCurrentRateInternal();
//To check if the amount of tokens for the current ICO phase is exhausted
//uint256 a = 1;
//amountOfIiino = (weiAmount.mul(currRate)).div(a);
amountOfIiino = weiAmount * currRate;
require(<FILL_ME>)
return amountOfIiino;
}
}
//function getCurrentRate returns the amount of iii for the amount of wei at the current point in time (now)
function getCurrentRateInternal() whenNotPaused internal view returns (uint,uint256) {
}
function buyTokensWithReferrer(address referrer) nonReentrant whenNotPaused external payable {
}
function getCurrentRate() whenNotPaused external view returns (uint,uint256) {
}
function buyTokens(address beneficiary) nonReentrant whenNotPaused external payable {
}
function forwardFunds() whenNotPaused internal {
}
}
| _totalSupply.add(amountOfIiino)<=noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev).add(noOfTokenAlocatedPerICOPhase.mul(multiplierForICO.add(1))) | 377,030 | _totalSupply.add(amountOfIiino)<=noOfTokenAlocatedForSeedRound.add(noOfTokenAlocatedForPresaleRound).add(noOfTokenAlocatedForDev).add(noOfTokenAlocatedPerICOPhase.mul(multiplierForICO.add(1))) |
null | contract IiinoCoinCrowdsale is Crowdsale, Pausable, ReentrancyGuard {
event ReferralAwarded(address indexed purchaser, address indexed referrer, uint256 iiinoPurchased, uint256 iiinoAwarded);
using SafeMath for uint256;
address devWallet;
uint256 noOfTokenAlocatedForDev;
uint256 public noOfTokenAlocatedForSeedRound;
uint256 public noOfTokenAlocatedForPresaleRound;
uint256 public totalNoOfTokenAlocated;
uint256 public noOfTokenAlocatedPerICOPhase; //The token allocation for each phase of the ICO
uint256 public noOfICOPhases; //No. of ICO phases
uint256 public seedRoundEndTime; // to be in seconds
uint256 public thresholdEtherLimitForSeedRound; //minimum amount of wei needed to participate
uint256 public moreTokenPerEtherForSeedRound; // the more amount of Iiinos given per ether during seed round
uint256 public moreTokenPerEtherForPresaleRound; //the more amount of Iiinos given per ether during presale round
uint256 public referralTokensAvailable; //To hold the value of the referral token limit.
uint256 public referralPercent; //The percentage of referral to be awarded on each order with a referrer
uint256 public referralTokensAllocated; // To hold the total number of token allocated to referrals
uint256 public presaleEndTime; // to be in seconds
uint256 public issueRateDecDuringICO; //The number of iiino that needs to be decreased for every next phase of the ICO
//uint256 public percentToMintPerDuration; //The percentage of Genesis ICO that will be minted every minting cycle
//uint256 public durationBetweenRewardMints; //The length of a reward minting cycle
function IiinoCoinCrowdsale(
uint256[] _params, // All the params that need to initialize the crowdsale as well as the iiino Token
address _wallet,
address _devTeamWallet,
address _iiinoTokenAddress
) public Crowdsale(_params[0], _params[1], _params[4], _wallet) {
}
function initialTransferToDevTeam() nonReentrant onlyOwner whenNotPaused external {
}
/*
//Temp Function to retreive values
function tempGetDataToCheck (uint indx, uint256 weiAmt) public view returns (uint256) {
//string temp = "thresholdEtherLimitForSeedRound =>" + thresholdEtherLimitForSeedRound + "Total Supply => " + token.totalSupply() + "noOfTokenAlocatedForSeedRound => " + noOfTokenAlocatedForSeedRound + "noOfTokenAlocatedForDev => " + noOfTokenAlocatedForDev + "rate => " + rate;
if (indx == 0)
return issueRateDecDuringICO;
else if (indx == 1)
return seedRoundEndTime;
else if (indx == 2)
return presaleEndTime;
else if (indx == 3)
return moreTokenPerEtherForSeedRound;
else if (indx == 4)
return moreTokenPerEtherForPresaleRound;
else if (indx == 5)
return noOfTokenAlocatedForDev;
else if (indx == 6)
return noOfTokenAlocatedForSeedRound;
else if (indx == 61)
return noOfTokenAlocatedForPresaleRound;
else if (indx == 7)
return totalNoOfTokenAlocated;
else if (indx == 8)
return noOfTokenAlocatedPerICOPhase;
else if (indx == 9)
return noOfICOPhases;
else if (indx == 10)
return thresholdEtherLimitForSeedRound;
else if (indx == 11)
return 0;//percentToMintPerDuration;
else if (indx == 12)
{
uint currentRate;
uint256 icoMultiplier;
(currentRate, icoMultiplier) = getCurrentRateInternal();
return currentRate;//durationBetweenRewardMints;
}
else if (indx == 13)
return token.totalSupply();
else if (indx == 14)
return getTokenAmount(weiAmt);
else if (indx == 15)
return now;
else if (indx == 16)
return startTime;
else if (indx == 17)
return endTime;
}
*/
function getTokenAmount (uint256 weiAmount) whenNotPaused internal view returns (uint256) {
}
//function getCurrentRate returns the amount of iii for the amount of wei at the current point in time (now)
function getCurrentRateInternal() whenNotPaused internal view returns (uint,uint256) {
}
function buyTokensWithReferrer(address referrer) nonReentrant whenNotPaused external payable {
address beneficiary = msg.sender;
require(referrer != address(0));
require(beneficiary != address(0));
require(validPurchase());
require(<FILL_ME>)
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
//To send the referrer his percentage of tokens.
uint256 referrerTokens = tokens.mul(referralPercent).div(100);
if (referralTokensAvailable > 0) {
if (referrerTokens > referralTokensAvailable) {
referrerTokens = referralTokensAvailable;
}
token.mint(referrer, referrerTokens);
referralTokensAvailable = referralTokensAvailable.sub(referrerTokens);
emit ReferralAwarded(msg.sender, referrer, tokens, referrerTokens);
}
forwardFunds();
}
function getCurrentRate() whenNotPaused external view returns (uint,uint256) {
}
function buyTokens(address beneficiary) nonReentrant whenNotPaused external payable {
}
function forwardFunds() whenNotPaused internal {
}
}
| msg.value>=(0.01ether) | 377,030 | msg.value>=(0.01ether) |
"All Pixel Zombies NFTs sold" | pragma solidity ^0.8.0;
contract PixelZombie is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenId;
uint256 public MAX_PZF = 10500;
uint256 public OWNER_RESERVED = 500;
uint256 public price = 50000000000000000; //0.05 Ether
uint256 public launchTime = 1631019600;
uint256 public endTime = 1631106000;
string baseTokenURI;
bool public saleOpen = true;
event PixelZombieMinted(uint256 totalMinted);
constructor(string memory baseURI) ERC721("Pixel Zombie Fellas", "PZF") {
}
//Get token Ids of all tokens owned by _owner
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
//Close sale if open, open sale if closed
function pauseSale() public onlyOwner {
}
//Close sale if open, open sale if closed
function unpauseSale() public onlyOwner {
}
function withdrawAll() public onlyOwner {
}
//mint Pixel Zombie
function mintPixelZombie(uint256 _count) public payable {
if (msg.sender != owner()) {
require(saleOpen, "Sale is paused please try again later");
}
if (msg.sender != owner()) {
require(block.timestamp >= launchTime, "Sale is not started yet");
}
require(
_count > 0 && _count <= 20,
"Min 1 & Max 20 Pixel Zombies can be minted per transaction"
);
if (msg.sender != owner()) {
require(<FILL_ME>)
}else{
require(
totalSupply() + _count <= (MAX_PZF),
"All Pixel Zombies NFTs sold"
);
}
require(
msg.value >= price * _count,
"Ether sent with this transaction is not correct"
);
address _to = msg.sender;
for (uint256 i = 0; i < _count; i++) {
_mint(_to);
if (msg.sender == owner()) {
OWNER_RESERVED--;
}
}
}
function airdrop(address[] calldata _recipients) external onlyOwner {
}
function _mint(address _to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setLaunchTime(uint256 _timestamp) external onlyOwner returns (bool){
}
function getLaunchTime() external view onlyOwner returns (uint256){
}
function getEndTime() view external onlyOwner returns (uint256){
}
function burnPixelZombies() external onlyOwner returns (uint256){
}
}
| totalSupply()+_count<=(MAX_PZF-OWNER_RESERVED),"All Pixel Zombies NFTs sold" | 377,033 | totalSupply()+_count<=(MAX_PZF-OWNER_RESERVED) |
"All Pixel Zombies NFTs sold" | pragma solidity ^0.8.0;
contract PixelZombie is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenId;
uint256 public MAX_PZF = 10500;
uint256 public OWNER_RESERVED = 500;
uint256 public price = 50000000000000000; //0.05 Ether
uint256 public launchTime = 1631019600;
uint256 public endTime = 1631106000;
string baseTokenURI;
bool public saleOpen = true;
event PixelZombieMinted(uint256 totalMinted);
constructor(string memory baseURI) ERC721("Pixel Zombie Fellas", "PZF") {
}
//Get token Ids of all tokens owned by _owner
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
//Close sale if open, open sale if closed
function pauseSale() public onlyOwner {
}
//Close sale if open, open sale if closed
function unpauseSale() public onlyOwner {
}
function withdrawAll() public onlyOwner {
}
//mint Pixel Zombie
function mintPixelZombie(uint256 _count) public payable {
if (msg.sender != owner()) {
require(saleOpen, "Sale is paused please try again later");
}
if (msg.sender != owner()) {
require(block.timestamp >= launchTime, "Sale is not started yet");
}
require(
_count > 0 && _count <= 20,
"Min 1 & Max 20 Pixel Zombies can be minted per transaction"
);
if (msg.sender != owner()) {
require(
totalSupply() + _count <= (MAX_PZF - OWNER_RESERVED),
"All Pixel Zombies NFTs sold"
);
}else{
require(<FILL_ME>)
}
require(
msg.value >= price * _count,
"Ether sent with this transaction is not correct"
);
address _to = msg.sender;
for (uint256 i = 0; i < _count; i++) {
_mint(_to);
if (msg.sender == owner()) {
OWNER_RESERVED--;
}
}
}
function airdrop(address[] calldata _recipients) external onlyOwner {
}
function _mint(address _to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setLaunchTime(uint256 _timestamp) external onlyOwner returns (bool){
}
function getLaunchTime() external view onlyOwner returns (uint256){
}
function getEndTime() view external onlyOwner returns (uint256){
}
function burnPixelZombies() external onlyOwner returns (uint256){
}
}
| totalSupply()+_count<=(MAX_PZF),"All Pixel Zombies NFTs sold" | 377,033 | totalSupply()+_count<=(MAX_PZF) |
"Airdrop minting will exceed maximum supply" | pragma solidity ^0.8.0;
contract PixelZombie is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenId;
uint256 public MAX_PZF = 10500;
uint256 public OWNER_RESERVED = 500;
uint256 public price = 50000000000000000; //0.05 Ether
uint256 public launchTime = 1631019600;
uint256 public endTime = 1631106000;
string baseTokenURI;
bool public saleOpen = true;
event PixelZombieMinted(uint256 totalMinted);
constructor(string memory baseURI) ERC721("Pixel Zombie Fellas", "PZF") {
}
//Get token Ids of all tokens owned by _owner
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
//Close sale if open, open sale if closed
function pauseSale() public onlyOwner {
}
//Close sale if open, open sale if closed
function unpauseSale() public onlyOwner {
}
function withdrawAll() public onlyOwner {
}
//mint Pixel Zombie
function mintPixelZombie(uint256 _count) public payable {
}
function airdrop(address[] calldata _recipients) external onlyOwner {
require(<FILL_ME>)
require(_recipients.length != 0, "Address not found for minting");
for (uint256 i = 0; i < _recipients.length; i++) {
require(_recipients[i] != address(0), "Minting to Null address");
_mint(_recipients[i]);
}
}
function _mint(address _to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setLaunchTime(uint256 _timestamp) external onlyOwner returns (bool){
}
function getLaunchTime() external view onlyOwner returns (uint256){
}
function getEndTime() view external onlyOwner returns (uint256){
}
function burnPixelZombies() external onlyOwner returns (uint256){
}
}
| totalSupply()+_recipients.length<=(MAX_PZF-OWNER_RESERVED),"Airdrop minting will exceed maximum supply" | 377,033 | totalSupply()+_recipients.length<=(MAX_PZF-OWNER_RESERVED) |
null | pragma solidity ^0.4.21;
/**
* @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 Subtracts 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) {
}
}
contract Ownable {
address public owner;
function Ownable() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface smartContract {
function transfer(address _to, uint256 _value) payable external;
function approve(address _spender, uint256 _value) external returns (bool success);
}
contract Basic is Ownable {
using SafeMath for uint256;
// This creates an array with all balances
mapping(address => uint256) public totalAmount;
mapping(address => uint256) public availableAmount;
mapping(address => uint256) public withdrawedAmount;
uint[] public periods;
uint256 public currentPeriod;
smartContract public contractAddress;
uint256 public ownerWithdrawalDate;
// fix for short address attack
modifier onlyPayloadSize(uint size) {
}
/**
* Constructor function
*
* transfer tokens to the smart contract here
*/
function Basic(address _contractAddress) public onlyOwner {
}
function _recalculateAvailable(address _addr) internal {
}
function addRecipient(address _from, uint256 _amount) external onlyOwner onlyPayloadSize(2 * 32) {
require(_from != 0x0);
require(<FILL_ME>)
totalAmount[_from] = _amount;
availableAmount[_from] = 0;
withdrawedAmount[_from] = 0;
}
function withdraw() public payable {
}
function _withdraw(address _addr) internal {
}
function triggerWithdraw(address _addr) public payable onlyOwner {
}
// owner may withdraw funds after some period of time
function withdrawToOwner(uint256 _amount) external onlyOwner {
}
function _updateCurrentPeriod() internal {
}
}
contract Bonus is Basic {
function Bonus(address _contractAddress) Basic(_contractAddress) public{
}
}
| totalAmount[_from]==0 | 377,038 | totalAmount[_from]==0 |
null | pragma solidity ^0.4.21;
/**
* @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 Subtracts 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) {
}
}
contract Ownable {
address public owner;
function Ownable() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface smartContract {
function transfer(address _to, uint256 _value) payable external;
function approve(address _spender, uint256 _value) external returns (bool success);
}
contract Basic is Ownable {
using SafeMath for uint256;
// This creates an array with all balances
mapping(address => uint256) public totalAmount;
mapping(address => uint256) public availableAmount;
mapping(address => uint256) public withdrawedAmount;
uint[] public periods;
uint256 public currentPeriod;
smartContract public contractAddress;
uint256 public ownerWithdrawalDate;
// fix for short address attack
modifier onlyPayloadSize(uint size) {
}
/**
* Constructor function
*
* transfer tokens to the smart contract here
*/
function Basic(address _contractAddress) public onlyOwner {
}
function _recalculateAvailable(address _addr) internal {
}
function addRecipient(address _from, uint256 _amount) external onlyOwner onlyPayloadSize(2 * 32) {
}
function withdraw() public payable {
}
function _withdraw(address _addr) internal {
require(_addr != 0x0);
require(<FILL_ME>)
//Recalculate available balance if time has come
_recalculateAvailable(_addr);
require(availableAmount[_addr] > 0);
uint256 available = availableAmount[_addr];
withdrawedAmount[_addr] = withdrawedAmount[_addr].add(available);
availableAmount[_addr] = 0;
contractAddress.transfer(_addr, available);
}
function triggerWithdraw(address _addr) public payable onlyOwner {
}
// owner may withdraw funds after some period of time
function withdrawToOwner(uint256 _amount) external onlyOwner {
}
function _updateCurrentPeriod() internal {
}
}
contract Bonus is Basic {
function Bonus(address _contractAddress) Basic(_contractAddress) public{
}
}
| totalAmount[_addr]>0 | 377,038 | totalAmount[_addr]>0 |
null | pragma solidity ^0.4.21;
/**
* @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 Subtracts 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) {
}
}
contract Ownable {
address public owner;
function Ownable() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface smartContract {
function transfer(address _to, uint256 _value) payable external;
function approve(address _spender, uint256 _value) external returns (bool success);
}
contract Basic is Ownable {
using SafeMath for uint256;
// This creates an array with all balances
mapping(address => uint256) public totalAmount;
mapping(address => uint256) public availableAmount;
mapping(address => uint256) public withdrawedAmount;
uint[] public periods;
uint256 public currentPeriod;
smartContract public contractAddress;
uint256 public ownerWithdrawalDate;
// fix for short address attack
modifier onlyPayloadSize(uint size) {
}
/**
* Constructor function
*
* transfer tokens to the smart contract here
*/
function Basic(address _contractAddress) public onlyOwner {
}
function _recalculateAvailable(address _addr) internal {
}
function addRecipient(address _from, uint256 _amount) external onlyOwner onlyPayloadSize(2 * 32) {
}
function withdraw() public payable {
}
function _withdraw(address _addr) internal {
require(_addr != 0x0);
require(totalAmount[_addr] > 0);
//Recalculate available balance if time has come
_recalculateAvailable(_addr);
require(<FILL_ME>)
uint256 available = availableAmount[_addr];
withdrawedAmount[_addr] = withdrawedAmount[_addr].add(available);
availableAmount[_addr] = 0;
contractAddress.transfer(_addr, available);
}
function triggerWithdraw(address _addr) public payable onlyOwner {
}
// owner may withdraw funds after some period of time
function withdrawToOwner(uint256 _amount) external onlyOwner {
}
function _updateCurrentPeriod() internal {
}
}
contract Bonus is Basic {
function Bonus(address _contractAddress) Basic(_contractAddress) public{
}
}
| availableAmount[_addr]>0 | 377,038 | availableAmount[_addr]>0 |
"Amount of Ether sent is not correct." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// Created By: LoMel
contract JungleDestroyers is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
uint256 public constant MAX_PUBLIC_MINT = 8858;
uint256 public constant AIRDROP_RESERVE = 30;
address public constant ARTIST_ADDRESS = 0x33379b2c46806B741F7a5a6fb7783d87f37AFaBc;
uint256 public pricePerJungleDestroyer = .04 ether;
string private baseURI;
constructor(
string memory name,
string memory symbol,
string memory uri) ERC721(name, symbol) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function mintJungleDestroyer(uint256 _numberOfJungleDestroyers) external payable nonReentrant{
require(currentState != ContractState.PAUSED, "The sale is not active.");
require(_numberOfJungleDestroyers > 0, "You cannot mint 0 Jungle Destroyers.");
require(<FILL_ME>)
require(SafeMath.add(_numMinted.current(), _numberOfJungleDestroyers) <= MAX_PUBLIC_MINT, "Exceeds maximum supply.");
for(uint i = 0; i < _numberOfJungleDestroyers; i++){
uint256 tokenIndex = _tokenIdCounter.current();
_numMinted.increment();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenIndex);
}
}
function airdropJungleDestroyer(uint256 _numberOfJungleDestroyers) external onlyOwner {
}
function getNFTPrice(uint256 _amount) public view returns (uint256) {
}
function payout() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| getNFTPrice(_numberOfJungleDestroyers)<=msg.value,"Amount of Ether sent is not correct." | 377,076 | getNFTPrice(_numberOfJungleDestroyers)<=msg.value |
"Exceeds maximum supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// Created By: LoMel
contract JungleDestroyers is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
uint256 public constant MAX_PUBLIC_MINT = 8858;
uint256 public constant AIRDROP_RESERVE = 30;
address public constant ARTIST_ADDRESS = 0x33379b2c46806B741F7a5a6fb7783d87f37AFaBc;
uint256 public pricePerJungleDestroyer = .04 ether;
string private baseURI;
constructor(
string memory name,
string memory symbol,
string memory uri) ERC721(name, symbol) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function mintJungleDestroyer(uint256 _numberOfJungleDestroyers) external payable nonReentrant{
require(currentState != ContractState.PAUSED, "The sale is not active.");
require(_numberOfJungleDestroyers > 0, "You cannot mint 0 Jungle Destroyers.");
require(getNFTPrice(_numberOfJungleDestroyers) <= msg.value, "Amount of Ether sent is not correct.");
require(<FILL_ME>)
for(uint i = 0; i < _numberOfJungleDestroyers; i++){
uint256 tokenIndex = _tokenIdCounter.current();
_numMinted.increment();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenIndex);
}
}
function airdropJungleDestroyer(uint256 _numberOfJungleDestroyers) external onlyOwner {
}
function getNFTPrice(uint256 _amount) public view returns (uint256) {
}
function payout() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| SafeMath.add(_numMinted.current(),_numberOfJungleDestroyers)<=MAX_PUBLIC_MINT,"Exceeds maximum supply." | 377,076 | SafeMath.add(_numMinted.current(),_numberOfJungleDestroyers)<=MAX_PUBLIC_MINT |
"Exceeds maximum airdrop reserve." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// Created By: LoMel
contract JungleDestroyers is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
uint256 public constant MAX_PUBLIC_MINT = 8858;
uint256 public constant AIRDROP_RESERVE = 30;
address public constant ARTIST_ADDRESS = 0x33379b2c46806B741F7a5a6fb7783d87f37AFaBc;
uint256 public pricePerJungleDestroyer = .04 ether;
string private baseURI;
constructor(
string memory name,
string memory symbol,
string memory uri) ERC721(name, symbol) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function mintJungleDestroyer(uint256 _numberOfJungleDestroyers) external payable nonReentrant{
}
function airdropJungleDestroyer(uint256 _numberOfJungleDestroyers) external onlyOwner {
require(_numberOfJungleDestroyers > 0, "You cannot mint 0 Jungle Destroyers.");
require(<FILL_ME>)
for(uint i = 0; i < _numberOfJungleDestroyers; i++){
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_numAirdroped.increment();
_safeMint(msg.sender, tokenId);
}
}
function getNFTPrice(uint256 _amount) public view returns (uint256) {
}
function payout() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| SafeMath.add(_numAirdroped.current(),_numberOfJungleDestroyers)<=AIRDROP_RESERVE,"Exceeds maximum airdrop reserve." | 377,076 | SafeMath.add(_numAirdroped.current(),_numberOfJungleDestroyers)<=AIRDROP_RESERVE |
null | pragma solidity 0.6.12;
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address, uint256) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address, uint) external returns (bool);
function transferFrom(address, address, uint256) 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Libera is ERC20 {
using SafeMath for uint256;
string public symbol;
string public name;
uint256 public decimals = 18;
uint256 public override totalSupply = 5000000 * (10 ** decimals);
mapping(address => mapping(address => uint256)) public override allowance;
mapping(address => uint256) public override balanceOf;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
}
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != address(0));
require(_value <= balanceOf[_from]);
require(<FILL_ME>)
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
}
function approve(address spender, uint256 value) public override returns (bool success) {
}
function transfer(address to, uint256 value) public override returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public override returns (bool success) {
}
}
| balanceOf[_to]<=balanceOf[_to].add(_value) | 377,151 | balanceOf[_to]<=balanceOf[_to].add(_value) |
"token already registered" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
import "openzeppelin-solidity/contracts/security/ReentrancyGuard.sol";
/// @title A simple stable vault
/// @author @gcosmintech
contract StablesInvestor is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
bool public paused;
mapping(address => bool) public supportedTokens;
address[] tokens;
uint256 public cap;
uint256 private constant _decimals = 18;
uint256 private _withdrawnTvl;
event CapChanged(address indexed user, uint256 oldCap, uint256 newCap);
event AddedNewToken(
address indexed user,
address indexed token,
uint256 timestamp
);
event RemovedToken(
address indexed user,
address indexed token,
uint256 timestamp
);
event Withdrawn(
address indexed user,
address indexed token,
address indexed destination,
uint256 timestamp,
uint256 amount,
uint256 capAmount
);
event Deposit(
address indexed user,
address indexed token,
uint256 timestamp,
uint256 amount,
uint256 capAmount
);
constructor() {
}
//
//---------
// Configuration
//---------
//
function pauseDeposit() external onlyOwner {
}
function unpauseDeposit() external onlyOwner {
}
/// @notice Set current strategy cap
/// @dev Use 18 decimals
/// @param newCap New cap
function setCap(uint256 newCap) external onlyOwner {
}
/// @notice Add a new token in the supported list
/// @param token Token's address
function addSupportedToken(address token) external onlyOwner {
require(token != address(0), "invalid token address");
require(<FILL_ME>)
supportedTokens[token] = true;
tokens.push(token);
emit AddedNewToken(msg.sender, token, block.timestamp);
}
/// @notice Removes an existing token from the supported list
/// @param token Token's address
function removeSupportedToken(address token) external onlyOwner {
}
/// @notice Withdraws balance of a specific token
/// @param token Token's address
/// @param destination Destination address
function withdraw(address token, address destination) external onlyOwner {
}
//
//---------
// Getters
//---------
//
/// @notice Get total strategy TVL
/// @return Total TVL (current + withdrawn)
function getTotalTVL() public view returns (uint256) {
}
/// @notice Get current strategy TVL
/// @return Current TVL
function getCurrentTVL() public view returns (uint256) {
}
/// @notice Get withdrawn TVL
/// @return Withdrawn TVL
function getWithdrawnTVL() public view returns (uint256) {
}
//
//---------
// Interactions
//---------
//
function deposit(address token, uint256 amount) external nonReentrant {
}
//
//---------
// Helpers
//---------
//
function _getCurrentBalance() private view returns (uint256) {
}
function _getCapValue(address token, uint256 amount)
private
view
returns (uint256)
{
}
function _find(address token) private view returns (uint256, bool) {
}
function _remove(uint256 index) private {
}
}
| supportedTokens[token]==false,"token already registered" | 377,154 | supportedTokens[token]==false |
"token not registered" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
import "openzeppelin-solidity/contracts/security/ReentrancyGuard.sol";
/// @title A simple stable vault
/// @author @gcosmintech
contract StablesInvestor is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
bool public paused;
mapping(address => bool) public supportedTokens;
address[] tokens;
uint256 public cap;
uint256 private constant _decimals = 18;
uint256 private _withdrawnTvl;
event CapChanged(address indexed user, uint256 oldCap, uint256 newCap);
event AddedNewToken(
address indexed user,
address indexed token,
uint256 timestamp
);
event RemovedToken(
address indexed user,
address indexed token,
uint256 timestamp
);
event Withdrawn(
address indexed user,
address indexed token,
address indexed destination,
uint256 timestamp,
uint256 amount,
uint256 capAmount
);
event Deposit(
address indexed user,
address indexed token,
uint256 timestamp,
uint256 amount,
uint256 capAmount
);
constructor() {
}
//
//---------
// Configuration
//---------
//
function pauseDeposit() external onlyOwner {
}
function unpauseDeposit() external onlyOwner {
}
/// @notice Set current strategy cap
/// @dev Use 18 decimals
/// @param newCap New cap
function setCap(uint256 newCap) external onlyOwner {
}
/// @notice Add a new token in the supported list
/// @param token Token's address
function addSupportedToken(address token) external onlyOwner {
}
/// @notice Removes an existing token from the supported list
/// @param token Token's address
function removeSupportedToken(address token) external onlyOwner {
require(token != address(0), "invalid token address");
require(<FILL_ME>)
supportedTokens[token] = false;
(uint256 index, bool found) = _find(token);
if (found == true) {
_remove(index);
}
emit RemovedToken(msg.sender, token, block.timestamp);
}
/// @notice Withdraws balance of a specific token
/// @param token Token's address
/// @param destination Destination address
function withdraw(address token, address destination) external onlyOwner {
}
//
//---------
// Getters
//---------
//
/// @notice Get total strategy TVL
/// @return Total TVL (current + withdrawn)
function getTotalTVL() public view returns (uint256) {
}
/// @notice Get current strategy TVL
/// @return Current TVL
function getCurrentTVL() public view returns (uint256) {
}
/// @notice Get withdrawn TVL
/// @return Withdrawn TVL
function getWithdrawnTVL() public view returns (uint256) {
}
//
//---------
// Interactions
//---------
//
function deposit(address token, uint256 amount) external nonReentrant {
}
//
//---------
// Helpers
//---------
//
function _getCurrentBalance() private view returns (uint256) {
}
function _getCapValue(address token, uint256 amount)
private
view
returns (uint256)
{
}
function _find(address token) private view returns (uint256, bool) {
}
function _remove(uint256 index) private {
}
}
| supportedTokens[token]==true,"token not registered" | 377,154 | supportedTokens[token]==true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.