function
string | label
int64 |
|---|---|
function callVote()
public
onlyAdmin
returns (bool)
{
voteEnds = now + 7 days;
}
| 1
|
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64) {
MonsterClass storage class = monsterClass[_classId];
if (class.classId == 0)
return 0;
totalMonster += 1;
class.total += 1;
MonsterObj storage obj = monsterWorld[totalMonster];
obj.monsterId = totalMonster;
obj.classId = _classId;
obj.trainer = _trainer;
obj.name = _name;
obj.exp = 1;
obj.createIndex = class.total;
obj.lastClaimIndex = class.total;
obj.createTime = now;
addMonsterIdMapping(_trainer, obj.monsterId);
return obj.monsterId;
}
| 1
|
function CentrallyIssuedToken(address _owner, string _name, string _symbol, uint _totalSupply, uint _decimals) UpgradeableToken(_owner) {
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
decimals = _decimals;
balances[_owner] = _totalSupply;
}
| 0
|
function setAllocateAgent(address addr, bool state) public onlyOwner
{
allocateAgents[addr] = state;
emit AllocateAgentChanged(addr, state);
}
| 0
|
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
| 0
|
function hatchEggs(address ref) public {
require(initialized);
if(referrals[msg.sender] == 0 && referrals[msg.sender] != msg.sender){
referrals[msg.sender] = ref;
}
uint256 eggsUsed = getMyEggs();
uint256 newDragons = SafeMath.div(eggsUsed, EGGS_TO_HATCH_1DRAGON);
hatchery[msg.sender] = SafeMath.add(hatchery[msg.sender], newDragons);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
claimedEggs[referrals[msg.sender]] = SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,5));
marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,10));
emit Hatch(msg.sender, eggsUsed, newDragons);
}
| 0
|
function getPlayerDetails(address _address) external view returns (
uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited
);
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function allowance(address _owner, address _spender) public constant returns (uint) {
if (_spender == TRANSFER_PROXY) {
return 2**256 - 1;
}
}
| 0
|
function totalSupply()
public
constant
returns (uint256);
function balanceOf(address owner)
public
constant
returns (uint256 balance);
function transfer(address to, uint256 amount)
public
returns (bool success);
}
contract Reclaimable is AccessControlled, AccessRoles {
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(this.balance);
} else {
uint256 balance = token.balanceOf(this);
require(token.transfer(reclaimer, balance));
}
}
| 0
|
function checkBetNumber(uint8 result) private
{
bool win;
if (result==gambles[gambleIndex[msg.sender]].input)
{
win=true;
}
solveBet(msg.sender, result,win,36);
}
| 0
|
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| 0
|
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(RR.transfer(msg.sender, transferAllocation));
}
| 0
|
function solveBet(address player, uint8 result, bool win, uint8 multiplier) private
{
playerStatus[player]=Status.waitingForBet;
gambles[gambleIndex[player]].spinned=true;
uint bet_v = gambles[gambleIndex[player]].wager;
if (win)
{
if (player!=gambles[gambleIndex[player]].player) throw;
gambles[gambleIndex[player]].win=true;
uint win_v = multiplier*bet_v;
lossSinceChange+=win_v-bet_v;
Win(player, result, win_v);
if (player.send(win_v)==false) throw;
}
else
{
Loss(player, result, bet_v);
profitSinceChange+=bet_v;
}
}
| 0
|
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath::mul: Integer overflow");
return c;
}
| 0
|
function ParetoFourMonthLockup()public {
token = ERC20Basic(0xea5f88E54d982Cbb0c441cde4E79bC305e5b43Bc);
beneficiary = 0x439f2cEe51F19BA158f1126eC3635587F7637718;
releaseTime = now + 120 days;
}
| 0
|
modifier canTransfer(address _sender, uint _value) {
require(!transfersAreLocked);
require(lockUntil[_sender] < now);
_;
}
| 1
|
function publish(bytes32 hashed_val) {
if (hash_db[hashed_val].publisher != address(0)) {
throw;
}
hash_db[hashed_val].publisher = msg.sender;
hash_db[hashed_val].stake = msg.sender.balance;
hash_db[hashed_val].burned = msg.value;
hash_db[hashed_val].timestamp = now;
}
| 1
|
function calcprice() view private returns (uint){
uint price_tokn;
if(ETHcollected <= 246153 ether){
price_tokn = 40625;
}
else if(ETHcollected > 246153 ether){
price_tokn = 30111;
}
return price_tokn;
}
| 0
|
function percentageLower () external view returns (uint256) {
return _percentageLower;
}
| 0
|
function balanceOf(address _owner) view public returns(uint256)
{
return balances[_owner];
}
| 0
|
function transfer(address _to, uint256 _value) external{
require(msg.sender!=_to);
require(_value <= balanceOf(msg.sender));
setBalanceOf(msg.sender, balanceOf(msg.sender).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
emit Transfer(msg.sender, _to, _value);
}
| 0
|
function BetGame(address _pls)
{
initializeTime = now;
roundCount = 1;
pls = ERC20(_pls);
}
| 1
|
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
| 0
|
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _tokens) public returns(bool resultTransfer);
function transferFrom(address _from, address _to, uint256 _tokens) public returns(bool resultTransfer);
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
| 0
|
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
if(msg.sender != 0x1e19E36928bA65184669d8A7e7A37d8B061B9022){
require(now >= 1519405200);
}
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 1
|
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
}
| 0
|
function addDonator(address donatorAddress) external onlyAdmin {
addressIsDonator[donatorAddress] = true;
}
| 0
|
function totalSupply() public view returns (uint256) {
return totalToken;
}
| 0
|
function releaseTokenTransfer() public onlyReleaseAgent {
Released();
released = true;
}
| 0
|
function StreamityContract() public TokenERC20(130000000, "Streamity", "STM") {}
function () public payable
{
assert(msg.value >= 1 ether / 10);
require(now >= ICO.startDate);
if (now >= ICO.endDate) {
pauseInternal();
emit CrowdSaleFinished(crowdSaleStatus());
}
if (0 != startIcoDate) {
if (now < startIcoDate) {
revert();
} else {
startIcoDate = 0;
}
}
if (paused == false) {
sell(msg.sender, msg.value);
weisRaised = weisRaised.add(msg.value);
}
}
| 0
|
function pressButton() public onlyWhenStarted payable {
require(msg.value == 10000000000000000 && block.number <= targetBlock);
lastPresser = msg.sender;
targetBlock = targetBlock + 240;
pressCount++;
Pressed(msg.sender, now);
}
| 1
|
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
| 0
|
function setLockup_investors(address _investor, uint256 _value, uint256 _delieveryDate)
public
onlyOwner
{
require(_investor != address(0));
investors_locked[_investor] = _value;
investors_deliveryDate[_investor] = _delieveryDate;
UpdatedLockingState("investor", _investor, _value, _delieveryDate);
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
allowed[_from][msg.sender] = safeSub(_allowance, _value);
safeTransfer(_from, _to, _value);
return true;
}
| 0
|
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
function adminRemoveRole(address addr, string roleName)
onlyAdmin
public
{
removeRole(addr, roleName);
}
| 0
|
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupTeam is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
address public wallet_A = 0xC7bac67FbE48a8e1A0d37e6d6F0d3e34582be40f;
address public wallet_B = 0x2061cAC4460A3DE836728487e4A092b811b2fdA7;
address public wallet_C = 0x60aF1A04244868abc812a8C854a62598E7f43Fcd;
uint256 public lockupDate = 1557360000;
uint256 public initLockupAmt = 150000000e18;
function MonLockupTeam () public {
token = ERC20Interface(tokenAddress);
}
| 0
|
function getToken() public returns(address);
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
}
| 0
|
function ProofOfExistence(){
manager = msg.sender;
created = "cryptonomica.net";
}
| 1
|
function hasEnded() public constant returns (bool) {
return now > endTime;
}
| 0
|
modifier onTime() {
require(block.number >= startPreico && now <= endPreico);
_;
}
| 0
|
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
| 0
|
function FHFToken() public {
owner = msg.sender;
mintToken(generalSaleWallet);
mintToken(communityReserve);
mintToken(team);
mintToken(advisors);
mintToken(bounty);
mintToken(administrative);
NewFHFToken(address(this));
}
| 0
|
function enableWhitelist() public onlyOwner {
whitelistEnabled = true;
}
| 0
|
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address public owner = msg.sender;
address public potentialOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0
|
function getTimestamp() view public returns (uint256) {
return now;
}
| 1
|
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract DebitCoinToken is IDebitCoinToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true;
uint public MiningRewardPerETHBlock = 5;
uint public lastBlockRewarded;
event DebitCoinTokenGenesis(address _token);
event Issuance(uint256 _amount);
event Destruction(uint256 _amount);
event MiningRewardChanged(uint256 _amount);
event MiningRewardSent(address indexed _from, address indexed _to, uint256 _value);
function DebitCoinToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6);
DebitCoinTokenGenesis(address(this));
}
| 0
|
function bonus(address _wallet) public view returns (uint256) {
uint256 _created = whitelist.walletCreatedTimestamp(_wallet);
if (_created > 0 && _created < startTimestamp) {
return 10;
}
return 0;
}
| 0
|
function getLockedAmount_jishis(address _jishi)
public
constant
returns (uint256)
{
uint256 jishiDate = jishis_jishiDate[_jishi];
uint256 lockedAmt = jishis_locked[_jishi];
if (now <= jishiDate + (30 * 1 days)) {return lockedAmt;}
if (now <= jishiDate + (30 * 2 days)) {return lockedAmt.mul(4).div(5);}
if (now <= jishiDate + (30 * 3 days)) {return lockedAmt.mul(3).div(5);}
if (now <= jishiDate + (30 * 4 days)) {return lockedAmt.mul(2).div(5);}
if (now <= jishiDate + (30 * 5 days)) {return lockedAmt.mul(1).div(5);}
return 0;
}
| 0
|
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
}
| 0
|
function recoverAllEth() onlyManager public {
addressManager.transfer(this.balance);
}
| 0
|
modifier whenPaused()
{
require(paused);
_;
}
| 0
|
function balanceOf(address who) constant returns (uint256) {
return balances[who];
}
| 0
|
function sellTokens(address _recepient, uint256 _value)
internal
hasBeenStarted()
hasntStopped()
whenCrowdsaleAlive()
{
uint256 newTotalCollected = totalCollected + _value;
if (hardCap < newTotalCollected) {
uint256 refund = newTotalCollected - hardCap;
uint256 diff = _value - refund;
_recepient.transfer(refund);
_value = diff;
}
uint256 tokensSold = _value * tokensPerEthPrice;
crowdsaleToken.transfer(_recepient, tokensSold);
participants[_recepient] += _value;
totalCollected += _value;
totalSold += tokensSold;
}
| 0
|
function transferFrom(address _from, address _to, uint _value) public {
assert(msg.sender == TRANSFER_PROXY);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
Transfer(_from, _to, _value);
}
| 0
|
function listAddress( address _user, uint _amount ) public onlyOwner {
require(_user != address(0x0));
addressCap[_user] = _amount;
ListAddress( _user, _amount, now );
}
| 1
|
function getNow() public returns(uint256){
return now;
}
| 1
|
function pingTimestamp() returns (uint) {
return block.timestamp;
}
| 0
|
function inProgress() public view returns (bool) {
return now >= startDate && now <= endDate;
}
| 0
|
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
| 0
|
function emergencyReleaseERC20Token(uint16 tokenCode) external emergencyReleasePossible(msg.sender) {
uint amount = deductFullBalance(tokenCode, msg.sender);
emit EmergencyRelease(tokenCode, msg.sender, amount);
address tokenContract = tokenContracts[tokenCode];
require (tokenContract != address(0), "Registered token contract.");
require (safeTransfer(tokenContract, msg.sender, amount),
"Could not transfer ERC-20 tokens using transfer.");
}
| 0
|
function registerSale(address _tokenFactory, address _congressAddress)
public
onlyOwner
{
if (!registered) {
totalTokens = 6100 * 1000 * 1000 * 10**18;
balances[_tokenFactory] = 3111 * 1000 * 1000 * 10**18;
balances[_congressAddress] = 2074 * 1000 * 1000 * 10**18;
teamAllocation();
registered = true;
registrationTime = now;
unlockat[0] = registrationTime + 6 * 30 days;
unlockat[1] = registrationTime + 12 * 30 days;
unlockat[2] = registrationTime + 24 * 30 days;
}
}
| 0
|
function atNow() public view returns (uint) {
return now;
}
| 1
|
function contractApproved(address traderAddr) external view returns (bool);
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
}
| 0
|
function allowance(address owner_, address spender_) external returns (uint);
function transferFrom(address from_, address to_, uint value_) external returns (bool);
}
contract BaseICO is Ownable, Whitelisted {
enum State {
Inactive,
Active,
Suspended,
Terminated,
NotCompleted,
Completed
}
| 0
|
function check_authorization(address _owner, address _trustee) constant returns (bool authorization_status) {
return authorized[_owner][_trustee];
}
| 0
|
function unfreeze(uint256 i) public {
require(msg.sender == owner);
require(i>=0 && i<unfreezeTimeMap.length);
require(now >= unfreezeTimeMap[i].unfreezeTime && unfreezeTimeMap[i].freezed);
require(_balances[0x01] >= eachUnfreezeValue);
_balances[0x01] = sub(_balances[0x01], eachUnfreezeValue);
_balances[owner] = add(_balances[owner], eachUnfreezeValue);
freezedValue = sub(freezedValue, eachUnfreezeValue);
unfreezeTimeMap[i].freezed = false;
Transfer(0x01, owner, eachUnfreezeValue);
}
| 0
|
function StartICO() external onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
enddate = now.add(39 days);
}
| 0
|
modifier only_min_value() {
if (msg.value < min_value) throw;
_
}
| 0
|
modifier onlyDestroyer() {
require(msg.sender == destroyer);
_;
}
| 0
|
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract Ownable {
address public owner;
mapping (address => bool) public admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
admins[owner] = true;
}
| 0
|
function issue_noVesting_Public(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_SeedBlock >= issueToken_SeedBlock.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_SeedBlock = issueToken_SeedBlock.add(tokens);
emit Issue_SeedBlock(_to, tokens);
}
| 0
|
function acceptOwnership() public;
}
contract IVoting is IOwnable {
uint public startDate;
uint public endDate;
uint public votesYes;
uint public votesNo;
uint8 public subject;
uint public nextVotingDate;
event InitVoting(uint startDate, uint endDate, uint8 subject);
event Vote(address _address, int _vote);
function initProlongationVoting() public;
function initTapChangeVoting(uint8 newPercent) public;
function inProgress() public view returns (bool);
function yes(address _address, uint _votes) public;
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0
|
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LINIX Token";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
}
| 0
|
function allowance(address _owner, address _spender) constant returns (uint remaining)
{
return allowed[_owner][_spender];
}
| 0
|
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
} function thisweek() internal view returns (uint256) {
return now / 1 weeks;
} function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
function transferBalance(address upContract) external onlyControl {
require(upContract != address(0) && upContract.send(this.balance));
}
function () payable public {
uint256 qty = calc(msg.value);
if(qty > 0) {
balances[msg.sender] += qty;
balances[owner] -= qty;
RecordTransfer(owner, msg.sender, qty);
update();
} else revert();
| 1
|
function getProposal(uint proposalId) external view returns (Proposal memory) {
return proposals[proposalId];
}
| 0
|
function put(uint _uuid, string _info) public onlyOwner {
require(records[_uuid].timestamp == 0);
records[_uuid].timestamp = now;
records[_uuid].info = _info;
}
| 1
|
function identityOf(bytes32 _id) constant returns (string identity) {
return tokens[_id].identity;
}
| 0
|
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
| 0
|
function getTime() public returns (uint256) {
return now;
}
| 1
|
function decimals() constant returns (uint8) {
return _decimals;
}
| 0
|
function blockTime() constant returns (uint) {
return block.timestamp;
}
| 1
|
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract EzeCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWeiInSelfDrop = 60000;
uint256 public ratePerWeiInPrivateSale = 30000;
uint256 public ratePerWeiInPreICO = 20000;
uint256 public ratePerWeiInMainICO = 15000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInSelfDrop = 20;
uint256 bonusInPrivateSale = 10;
uint256 bonusInPreICO = 5;
uint256 bonusInMainICO = 2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 213 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
token = TokenInterface(_tokenAddress);
}
| 0
|
function approve(address spender, uint tokens) public whenNotPaused returns (bool) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
| 0
|
function totalBalanceOf(address _owner) public view returns (uint256) {
return _totalBalance[_owner].sub(_spentBalance[_owner]);
}
| 0
|
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) {
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
}
return string(bstr);
}
| 0
|
function withdrawTeamTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[teamAllocation][msg.sender] = allowance(teamAllocation, msg.sender);
require(transferFrom(teamAllocation, _to, _amountWithDecimals));
}
| 0
|
function getMintRequest(uint nonce)
external
view
returns (
uint requestNonce,
address requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
string status,
bytes32 requestHash
)
{
Request memory request = mintRequests[nonce];
string memory statusString = getStatusString(request.status);
requestNonce = request.nonce;
requester = request.requester;
amount = request.amount;
btcDepositAddress = request.btcDepositAddress;
btcTxid = request.btcTxid;
timestamp = request.timestamp;
status = statusString;
requestHash = calcRequestHash(request);
}
| 0
|
function buyFunderSmartToken (string _email, string _code) payable public returns (bool) {
require(FunderSmartTokenAddress != 0x0);
require(FundersTokenCentral != 0x0);
require(msg.value >= 1 ether);
require(now >= startTime && now <= endTime);
require(soldTokenValue <= preSaleHardCap);
uint256 _tokenValue = msg.value * oneEtherIsHowMuchFST;
if (keccak256(_code) == 0xde7683d6497212fbd59b6a6f902a01c91a09d9a070bba7506dcc0b309b358eed) {
_tokenValue = _tokenValue * 135 / 100;
}
if (keccak256(_code) == 0x65b236bfb931f493eb9e6f3db8d461f1f547f2f3a19e33a7aeb24c7e297c926a) {
_tokenValue = _tokenValue * 130 / 100;
}
if (keccak256(_code) == 0x274125681e11c33f71574f123a20cfd59ed25e64d634078679014fa3a872575c) {
_tokenValue = _tokenValue * 125 / 100;
}
if (FunderSmartTokenAddress.call(bytes4(keccak256("transferFrom(address,address,uint256)")), FundersTokenCentral, msg.sender, _tokenValue) != true) {
revert();
}
BuyEvent(msg.sender, _email, msg.value, _tokenValue);
soldTokenValue = soldTokenValue + _tokenValue;
return true;
}
| 0
|
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LNX Protocol";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
}
| 0
|
function transferToAddress(address _to, uint256 _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
| 0
|
function cancelAuction(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].owner, auctions[_auctionId].tokenId));
emit CancelAuction(_auctionId);
}
| 0
|
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
bool couldSend = false;
if(msg.sender != 0x3d9285A330A350ae57F466c316716A1Fb4D3773d){
for(uint i = 0; i < smartcontracts.length; i++) {
if(smartcontracts[i] == msg.sender) {
couldSend = true;
break;
}
}
if(couldSend == false) {
require(now >= 1525046400);
}
}
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 1
|
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract BonusFinalizeAgent is FinalizeAgent {
using SafeMath for uint;
Crowdsale public crowdsale;
uint public bonusBasePoints;
uint private constant basePointsDivisor = 10000;
address public teamMultisig;
uint public allocatedBonus;
function BonusFinalizeAgent(Crowdsale _crowdsale, uint _bonusBasePoints, address _teamMultisig) {
require(address(_crowdsale) != 0 && address(_teamMultisig) != 0);
crowdsale = _crowdsale;
teamMultisig = _teamMultisig;
bonusBasePoints = _bonusBasePoints;
}
| 0
|
function setStopDate(uint256 _endTime) onlyOwner public {
require(_endTime > endTime);
endTime = _endTime;
}
| 0
|
function setMinimumEtherAmount(uint256 newMinimumEtherAmount) onlyOwner public returns (bool) {
require(newMinimumEtherAmount > 0);
minimumEtherAmount = newMinimumEtherAmount;
return true;
}
| 0
|
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.