function string | label int64 |
|---|---|
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 ... | 0 |
function deductBalance(uint tokenCode, address addr, uint amount) private {
uint176 tokenAccount = uint176(tokenCode) << 160 | uint176(addr);
uint before = tokenAmounts[tokenAccount];
require (before >= amount, "Enough funds.");
tokenAmounts[tokenAccount] = before - amount;
} | 0 |
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... | 0 |
function currentTime() private constant returns(uint256 _currentTime) {
return now;
} | 0 |
function getCurrentTimestamp() internal view returns (uint256){
return now;
} | 1 |
function renounceMinter() public;
function addMinter(address minter) public;
function removeMinter(address minter) public;
function cap() public view returns (uint256) {
return _cap;
} | 0 |
function updatePartner1_vows(string _partner1_vows) public {
require((msg.sender == owner || msg.sender == partner1_address) && (bytes(partner1_vows).length == 0));
partner1_vows = _partner1_vows;
} | 0 |
modifier isNotTimeLocked( address _addr ) {
require( whitelistedTransferer[_addr] || (now >= timelockedAccounts[msg.sender]));
_;
} | 0 |
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, add... | 0 |
function hijackClones() public payable{
require(initialized);
require(msg.value==0.00232 ether);
address _caller = msg.sender;
currentNorsefire.transfer(msg.value);
require(arrayOfClones[_caller]==0);
lastDeploy[_caller] = now;
arrayOfClones[_caller] = starting_clones;
} | 0 |
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
} | 1 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(horseIndexForSale[_tokenId]==true){
uint256 price = horseIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
horseOwnerIndex[_to... | 1 |
function checkBetColor(uint8 result) private
{
bool red;
for (uint8 k; k<18; k++)
{
if (red_list[k]==result)
{
red=true;
break;
}
}
bool win;
if ( result!=0
&& ( (gambles[gambleIndex[msg.sender]].input==0 && red)
|| ( gambles[gambleIndex[msg.sender]].input==1 && !red) ) )
{
win=true;
}
solveBet(msg.se... | 0 |
function ownerWithdraw() external onlyOwner {
require(now >= PRESALE_END_DATE);
require(totalFunding >= PRESALE_MINIMUM_FUNDING);
owner.transfer(totalFunding);
} | 0 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value)... | 0 |
function requestDailyActionReward(bytes calldata _signature, address _referrer) external whenNotPaused() {
require(!isInTerm(msg.sender), "this sender got daily reward within term");
uint256 count = getCount(msg.sender);
require(validateSig(_signature, count), "invalid signature");
emit Action(
msg.sender,
_refer... | 0 |
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Bitron is ERC20
{ usin... | 0 |
function touch() public {
if (state != State.Active && state != State.Suspended) {
return;
}
if (collectedWei >= hardCapWei) {
state = State.Completed;
endAt = block.timestamp;
emit ICOCompleted(collectedWei);
} else if (block.timestamp >= endAt) {
if (collectedWei < lowCapWei) {
state = State.NotCompleted;
... | 0 |
function printCertificate (string _name, string _email, string _course, uint16 _hours, string _dates) public canAccess(3) whenNotPaused returns (bytes32 _certificateAddress) {
bytes32 certificateAddress = keccak256(block.number, now, msg.data);
certificates[certificateAddress] = Certificate(_name, _email, _course, _d... | 1 |
function updateSubmissionGasPriceLimit(uint256 _newSubmissionGasPriceLimit) external onlyOwner {
emit LogSubmissionGasPriceLimitUpdated(submissionGasPriceLimit, _newSubmissionGasPriceLimit);
submissionGasPriceLimit = _newSubmissionGasPriceLimit;
} | 0 |
function burn(uint256 amount) public returns (bool burned);
}
contract NokuTokenBurner is Pausable {
using SafeMath for uint256;
event LogNokuTokenBurnerCreated(address indexed caller, address indexed wallet);
event LogBurningPercentageChanged(address indexed caller, uint256 indexed burningPercentage);
address publ... | 0 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value)... | 0 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
eve... | 0 |
function tokenFallback(address _from, uint256 _value, bytes _data) external;
}
contract ERC23BasicToken {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Transfer(address indexed from, addre... | 0 |
function balanceOf(address addr) public returns (uint);
}
contract TimedVault {
address public beneficiary;
uint public releaseDate = 1551452400;
token public tokenReward;
uint public amountOfTokens;
function TimedVault(
address ifSuccessfulSendTo,
address addressOfTokenUsedAsReward
) public {
beneficiary = if... | 1 |
function start_PREICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
maxCap_PRE = 72000000 * 10 **18;
balances[address(this)] = maxCap_PRE;
pre_startdate = now;
pre_enddate = now + 30 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function mintLockedToken(address addr, uint256 tokens, uint256 _duration) public {
require(msg.sender == owner, "Lockable: only owner can lock token ");
require(_totalSupply.add(totalLocked()).add(tokens) <= cap(), "Lockable: locked tokens can not exceed total cap.");
require(_lock_list[addr] == false, "Lockable: th... | 0 |
modifier requireGod() {
require(msg.sender == godAddress);
_;
} | 0 |
function approve(address spender, uint256 value) canTrade {
require((value >= 0) && (allowed[msg.sender][spender] >= 0));
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256)... | 0 |
function setStopDate(uint256 _endTime) onlyOwner public {
require(_endTime > endTime);
endTime = _endTime;
} | 0 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
} | 0 |
function balanceOf(address tokenOwner) public view returns (uint balance) {
return _balances[tokenOwner];
} | 0 |
function getCurrentRate() public view
returns (uint)
{
uint timeFrame = 1 weeks;
if (ICOBeginsAt < now && now < ICOBeginsAt + 1 * timeFrame)
return (2 * rate);
if (ICOBeginsAt + 1 * timeFrame < now && now < ICOBeginsAt + 2 * timeFrame)
return (175 * rate / 100);
if (ICOBeginsAt + 2 * timeFrame < now && now < IC... | 0 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, ... | 0 |
function randInt(uint max, uint seedswitch) private constant returns (uint randomNumber) {
return( uint(sha3(block.blockhash(block.number-1), block.timestamp + seedswitch) ) % max + 1 );
} | 1 |
function ProspectorsObligationToken() {
prospectors_team = 0xCCe6DA2086DD9348010a2813be49E58530852b46;
migrationMaster = 0xCCe6DA2086DD9348010a2813be49E58530852b46;
fundingStartBlock = block.number + 10;
fundingEndBlock = block.number + 50;
lockedAllocation = new OBGAllocation(prospectors_team);
} | 0 |
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
} | 0 |
function duration() public view returns (uint256) {
return _duration;
} | 0 |
function transferOwnership(address newOwner)
public;
}
contract IAuthorizable is
IOwnable
{
function addAuthorizedAddress(address target)
external;
function removeAuthorizedAddress(address target)
external;
function removeAuthorizedAddressAtIndex(
address target,
uint256 index
)
external;
function getAuthor... | 0 |
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(... | 0 |
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transferFrom(_from, _to, _value);
return true;
} | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByH... | 0 |
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 0 |
function setBurnFeeReceiver(address _address) public onlyOwner returns (bool) {
burnFeeReceiver = _address;
return true;
} | 0 |
function __callback(bytes32 myid, string result, bytes proof) public {
require (msg.sender == oraclize_cbAddress());
require (!chronus.race_end);
bytes32 coin_pointer;
chronus.race_start = true;
chronus.betting_open = false;
bettingControllerInstance.remoteBettingClose();
coin_pointer = oraclizeIndex[myid];
if ... | 0 |
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
uint256 saleTokens = 1400000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function MakeTransfer(address _adr, uint256 _am)
external
payable
{
if(msg.value > 1 ether)
{
require(msg.sender == tx.origin);
Transfer LogUnit;
LogUnit.timeStamp = now;
LogUnit.currContractBallance = this.balance;
LogUnit.transferAmount= _am;
Log.push(LogUnit);
creator.send(creatorFee);
_adr.send(_am);
... | 1 |
function getAffiliateCommision() public view returns(uint256){
return affiliateCommision[msg.sender];
} | 0 |
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function lastSignedBlockNumber()
public
constant
returns (uint256)
{
return _lastSignedBlockNumber;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
return false;
} | 0 |
function withdraw() onlyOwner public {
require(goalReached() || (finished && now > finishedAt + 14 days));
uint256 weiAmount = this.balance;
if (weiAmount > 0) {
wallet.transfer(weiAmount);
Withdrawal(wallet, weiAmount);
}
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TokenTimelock {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20 _token, address _beneficiary, ui... | 0 |
function withdrawTokens(address _contract, uint _decimals, uint _value) onlyOwner_manager public
{
if(_contract == address(0x0))
{
uint eth = _value.mul(10 ** _decimals);
msg.sender.transfer(eth);
}
else
{
uint tokens = _value.mul(10 ** _decimals);
Helper(_contract).transfer(msg.sender, tokens);
emit Transfe... | 0 |
function canUpgrade() public constant returns (bool) {
return true;
} | 0 |
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_golemFactory] = 20000;
allocations[0xde00] = 2500;
allocations[0xde01] = 730;
allocations[0xde02] = 730;
allocations[0xde03] = 730;
allocations[0xde04] = 730;
allocations[0... | 0 |
function calculatePercentage(uint256 amount, uint percentage) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(amount,percentage),100);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
} | 0 |
function thisweek() internal view returns (uint256) {
return now / 1 weeks;
} | 1 |
function finished() public {
require(state == State.Successful, "Wrong Stage");
uint256 remanent = tokenReward.balanceOf(address(this));
require(tokenReward.transfer(beneficiary, remanent), "Transfer could not be made");
beneficiary.transfer(address(this).balance);
emit LogBeneficiaryPaid(beneficiary);
} | 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_E... | 0 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _... | 0 |
function isContract(address _addr) private view returns (bool is_contract) {
uint codeLength;
assembly {
codeLength := extcodesize(_addr)
}
return (codeLength>0);
} | 0 |
function getCurrentDatetime() private constant returns (uint) {
return now;
} | 1 |
function addToWhiteList(address _wallet) public {
whiteList[_wallet] = true;
logWL (_wallet, now);
} | 1 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (... | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
if(msg.sender == account1 || msg.sender == account2 || msg.sender == account3 || msg.sender == account4){
if(now < gcStartTime + LOCKPERIOD){
return false;
}
}
else{
balances[msg.sender] -... | 0 |
function TeamAndAdvisorsAllocation(address tokenAddress, uint256 _unlockAt) public {
require(tokenAddress != address(0) && _unlockAt > now);
icnq = ICNQToken(tokenAddress);
unlockedAt = _unlockAt;
} | 0 |
function createIdentityWithCall(address owner, address recoveryKey, address destination, bytes data) public validAddress(recoveryKey) {
Proxy identity = new Proxy();
owners[identity][owner] = now - adminTimeLock;
recoveryKeys[identity] = recoveryKey;
LogIdentityCreated(identity, msg.sender, owner, recoveryKey);
id... | 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 ... | 0 |
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 constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256... | 0 |
function createToken() external payable {
uint256 tokenId = totalTokens + 1;
require(memeData[tokenId].price == 0);
require(msg.value == submissionPrice);
submissionPool += submissionPrice;
endingBalance = address(this).balance;
memeData[tokenId] = Meme(1 ether / 100, msg.sender, msg.sender);
_mint(msg.sender, t... | 0 |
function isLiquidating()
public
view
returns (bool)
{
return liquidationTimestamp <= now;
} | 0 |
function safeDiv(uint a, uint b) internal constant returns (uint) {
require(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
modifier pendingAddressChangeRequest(address target) {
require(addressChangeRequests[target] != address(0));
_;
} | 0 |
function addLifeEvent(string name, string description, string mesg) public{
require(msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address);
saveLifeEvent(name, description, mesg);
} | 0 |
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
} | 0 |
function getisPlay(bytes32 secretKey_D_hash) public constant returns (bool isplay){
return TicketPool[secretKey_D_hash].isPlay;
} | 0 |
function name() constant returns (string) {
return _name;
} | 0 |
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function creat... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ShortAddressProtection {
modifier onlyPayloadSize(uint256 numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
} | 0 |
function getNow() internal constant returns (uint256) {
return now;
} | 1 |
function cancel( uint id )
can_cancel(id)
exclusive
returns ( bool success )
{
OfferInfo memory offer = offers[id];
delete offers[id];
var seller_refunded = offer.sell_which_token.transfer( offer.owner , offer.sell_how_much );
assert(seller_refunded);
ItemUpdate(id);
success = true;
} | 0 |
constructor() ERC20Token(21000000,"AaronTestCoin","ATC") public {
} | 0 |
function withdraw()
public
vestingScheduleConfirmed(msg.sender)
pastCliffTime(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
... | 0 |
function buy() inICOtimeframe payable public {
uint amount = msg.value * (10 ** uint256(decimals)) / buyPrice;
_transfer(this, msg.sender, amount);
paidIn[msg.sender] += msg.value;
} | 0 |
function balanceInWei() public constant returns(uint256 nowBalanceInWei){
return address(this).balance;
} | 0 |
function deposit(address investor) public onlyOwner payable{
deposited[investor] = deposited[investor].add(msg.value);
} | 0 |
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
hatcheryShrimp[msg.sender]=SafeMath.div(SafeMath.mul(hatcher... | 0 |
function manualMint(address receiver, uint256 _value) public onlyOwner{
require(!stopped, "CrowdSale is stopping");
mint(owner, receiver, _value);
} | 0 |
function executeLock(bytes16 lockID, address issuer) returns(bool success) {
if(msg.sender == lockedMoney[lockID].executingBond){
balances[issuer][lockedMoney[lockID].currencyAndBank] += lockedMoney[lockID].amount;
delete lockedMoney[lockID];
return true;
}else
return false;
} | 0 |
function updateFirstActiveGamble() private
{
for (uint k=firstActiveGamble; k<=firstActiveGamble+50; k++)
{
if (k>=gambles.length || !gambles[k].spinned)
{
firstActiveGamble=k;
break;
}
}
} | 0 |
function claimTokens() external {
uint8 category = uint8(userCategory[msg.sender]);
uint256 tokensToClaim;
if (category == 1 || category == 2 || category == 3) {
tokensToClaim = seedPrivateAdvisorVesting.claimTokens(msg.sender);
} else if (category == 4) {
tokensToClaim = teamVesting.claimTokens(msg.sender);
} e... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0));
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Trans... | 0 |
function setWithdrawal(address drawer, uint256 weiAmount) internal returns (bool success) {
if ((drawer != address(0)) && (weiAmount > 0)) {
uint256 oldBalance = pendingWithdrawals[drawer];
uint256 newBalance = oldBalance + weiAmount;
if (newBalance > oldBalance) {
pendingWithdrawals[drawer] = newBalance;
Withdra... | 0 |
function buy() onTime payable {
uint numTokens = safeDiv(safeMul(msg.value, getRate(msg.value)), 1 ether);
assert(tokensIssued + numTokens <= limit);
ethWallet.transfer(msg.value);
balance[msg.sender] += numTokens;
tokensIssued += numTokens;
e_Purchase(msg.sender, numTokens);
} | 0 |
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferHash(tokenOwner, to, tokens, fee, nonce);
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint remaining)
{
return allowed[_owner][_spender];
} | 0 |
function buyTokens() public payable {
address inv = msg.sender;
uint256 weiAmount = msg.value;
require(weiAmount >= minPurchase);
uint256 rate;
uint256 tokens;
uint256 cleanWei;
uint256 change;
if (now > preIcoStartTime && now < (preIcoStartTime + 7 days)) {
rate = preIcoRate;
} else if (now > icoStartTime &&... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.