func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function buyTokens(address _beneficiary) payable public{
uint256 weiAmount = msg.value;
if (checksOn) {
_preValidatePurchase(_beneficiary, weiAmount);
}
uint256 tokens = _getTokenAmount(weiAmount);
tokensRaised = tokensRaised.add(tokens);
minterContract.mint(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_forwardFunds();
} | 1 | 1,137 |
function withdrawByEmergency(string keyword) onlyByEmergency(keyword)
{
require(now > authorityRequestTime + 1 days);
require(keccak256(keyword) == keywordHash);
require(stage == Stages.AuthorityRequested);
msg.sender.transfer(this.balance);
} | 1 | 592 |
function _getSubscription(bytes32 productId, address subscriber) internal constant returns (bool subIsValid, Product storage, TimeBasedSubscription storage) {
Product storage p = products[productId];
require(p.id != 0);
TimeBasedSubscription storage s = p.subscriptions[subscriber];
return (s.endTimestamp >= block.timestamp, p, s);
} | 1 | 972 |
function setRule(uint16 _role, uint _baseLockPercent, uint _startLockTime, uint _stopLockTime,uint _linearRelease) onlyOwner {
assert(_startLockTime > block.timestamp);
assert(_stopLockTime > _startLockTime);
roleRule[_role] = LockRule({
baseLockPercent: _baseLockPercent,
startLockTime: _startLockTime,
stopLockTime: _stopLockTime,
linearRelease: _linearRelease
});
} | 1 | 795 |
function _transfer(address _from, address _to, uint256 _value) internal
{
erc1155.proxyTransfer20(_from, _to, tokenId, _value);
} | 0 | 3,020 |
function updateDocumentPoll(bytes32 _proposal)
public
returns (bool majority)
{
require(!documentHasAchievedMajority[_proposal]);
Poll storage poll = documentPolls[_proposal];
majority = checkPollMajority(poll);
if (majority)
{
documentHasAchievedMajority[_proposal] = true;
documentMajorities.push(_proposal);
emit DocumentMajority(_proposal);
}
return majority;
} | 1 | 1,711 |
function getMinerHashRate(uint256 _halving)
public
constant
returns(bool, uint256)
{
return getHashRateOf(msg.sender, _halving);
} | 0 | 3,387 |
function setVesting(
address _newVesting
)
onlyOwner
external returns (bool)
{
require(address(vestingWallet) != _newVesting && _newVesting != 0x0);
vestingWallet = Vesting(_newVesting);
shareToken.approve(address(vestingWallet), TEAM.add(PARTNERS));
return true;
} | 1 | 36 |
function airdrop(uint256 _temp)
private
view
returns(bool)
{
uint8 cc= 0;
uint8[5] memory randomNum;
if(_temp == 0){
randomNum[0]=6;
randomNum[1]=22;
randomNum[2]=38;
randomNum[3]=59;
randomNum[4]=96;
cc = 5;
}else if(_temp == 1){
randomNum[0]=9;
randomNum[1]=25;
randomNum[2]=65;
randomNum[3]=79;
cc = 4;
}else if(_temp == 2){
randomNum[0]=2;
randomNum[1]=57;
randomNum[2]=32;
cc = 3;
}else if(_temp == 3){
randomNum[0]=44;
randomNum[1]=90;
cc = 2;
}
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
seed = seed - ((seed / 100) * 100);
for(uint j=0;j<cc;j++)
{
if(randomNum[j] == seed)
{
return(true);
}
}
return(false);
} | 1 | 453 |
function random() internal view returns (bool) {
uint maxRange = 2**(8* 7);
for(uint8 a = 0 ; a < 8; a++){
uint randomNumber = uint( keccak256(abi.encodePacked(msg.sender,blockhash(block.number), block.timestamp )) ) % maxRange;
if ((randomNumber % 13) % 19 == 0){
return true;
break;
}
}
return false;
} | 1 | 913 |
function processPayment(uint moneyValue, bytes refData) private
{
if (msg.sender == laxmi)
{
totalSelfInvest = totalSelfInvest.add(moneyValue);
emit LogSelfInvestment(moneyValue);
return;
}
if (moneyValue == 0)
{
preparePayment();
return;
}
if (moneyValue < minimalDeposit)
{
totalPenalty = totalPenalty.add(moneyValue);
emit LogMinimalDepositPayment(msg.sender, moneyValue, totalPenalty);
return;
}
address referrer = bytesToAddress(refData);
if (user[msg.sender].balance > 0 ||
refData.length != 20 ||
moneyValue > getCurrentMaximalDeposit() ||
referrer != laxmi &&
(
user[referrer].balance <= 0 ||
referrer == msg.sender)
)
{
uint amount = moneyValue.mul(procReturn).div(procKoef);
totalPenalty = totalPenalty.add(moneyValue.sub(amount));
emit LogPenaltyPayment(msg.sender, user[msg.sender].balance, refData.length, referrer, user[referrer].balance, moneyValue, amount, totalPenalty);
msg.sender.transfer(amount);
return;
}
uint nDay = getCurrentDay();
uint restDepositPerDay = getDayRestDepositLimit(nDay);
uint addDeposit = moneyValue;
if (moneyValue > restDepositPerDay)
{
uint returnDeposit = moneyValue.sub(restDepositPerDay);
uint returnAmount = returnDeposit.mul(procReturn).div(procKoef);
addDeposit = addDeposit.sub(returnDeposit);
totalPenalty = totalPenalty.add(returnDeposit.sub(returnAmount));
emit LogExceededRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, returnDeposit, returnAmount, totalPenalty, addDeposit);
msg.sender.transfer(returnAmount);
}
usedDeposit[nDay] = usedDeposit[nDay].add(addDeposit);
emit LogUsedRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, addDeposit, usedDeposit[nDay]);
registerInvestor(referrer);
sendOwnerFee(addDeposit);
calcBonusReferrers(referrer, addDeposit);
updateInvestBalance(addDeposit);
} | 0 | 4,259 |
function contractorReleaseFunds(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee
) external onlyContractor(_contractor)
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].status == STATUS_JOB_COMPLETED);
require(block.timestamp > jobEscrows[jobHash].jobCompleteDate + 4 weeks);
uint256 jobValue = hirerEscrowMap[_hirer][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
emit ContractorReleased(
jobHash,
_hirer,
_contractor,
jobValue);
emit AddFeesToCoinSparrowPool(jobHash, _fee);
delete jobEscrows[jobHash];
delete hirerEscrowMap[_hirer][jobHash];
feesAvailableForWithdraw = feesAvailableForWithdraw.add(_fee);
totalInEscrow = totalInEscrow.sub(jobValue);
_contractor.transfer(jobValue.sub(_fee));
} | 1 | 1,199 |
functions
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) public constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract BonusFinalizeAgent is FinalizeAgent, SafeMathLib {
CrowdsaleToken public token;
Crowdsale public crowdsale;
uint256 public allocatedTokens;
uint256 tokenCap;
address walletAddress;
function BonusFinalizeAgent(CrowdsaleToken _token, Crowdsale _crowdsale, uint256 _tokenCap, address _walletAddress) public {
token = _token;
crowdsale = _crowdsale;
require(address(crowdsale) != 0);
tokenCap = _tokenCap;
walletAddress = _walletAddress;
} | 1 | 1,274 |
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(_from) >= _value);
return super.transferFrom(_from, _to, _value);
} | 1 | 2,375 |
function _validateBidParameters(
int[] _xs,
int[] _ys,
address _beneficiary,
ERC20 _fromToken
) internal view
{
require(startTime <= block.timestamp, "The auction has not started");
require(
status == Status.created &&
block.timestamp.sub(startTime) <= duration,
"The auction has finished"
);
require(tx.gasprice <= gasPriceLimit, "Gas price limit exceeded");
require(_beneficiary != address(0), "The beneficiary could not be the 0 address");
require(_xs.length > 0, "You should bid for at least one LAND");
require(_xs.length <= landsLimitPerBid, "LAND limit exceeded");
require(_xs.length == _ys.length, "X values length should be equal to Y values length");
require(tokensAllowed[address(_fromToken)].isAllowed, "Token not allowed");
for (uint256 i = 0; i < _xs.length; i++) {
require(
-150 <= _xs[i] && _xs[i] <= 150 && -150 <= _ys[i] && _ys[i] <= 150,
"The coordinates should be inside bounds -150 & 150"
);
}
} | 1 | 37 |
function TryUnLockCreatorBalance() public {
while(unLockIdx > 0 && block.timestamp >= nextUnLockTime){
uint256 append = creatorsLocked/unLockIdx;
creatorsLocked -= append;
unLockIdx -= 1;
nextUnLockTime = block.timestamp + ONE_YEAR_TIME_LEN;
}
} | 1 | 974 |
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, POOHMOXDatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit POOHMOXevents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.POOHAmount,
_eventData_.genAmount,
_eventData_.potAmount
);
} | 0 | 3,195 |
function _mint(uint _timestamp) internal hasMintPermission returns (bool) {
uint16 year = getYear(_timestamp);
require(mintedHistory[year].percent == 0);
uint256 amount = totalSupply_.mul(200).div(10000);
totalSupply_ = totalSupply_.add(amount);
balances[msg.sender] = balances[msg.sender].add(amount);
mintedHistory[year] = MintRecord({
percent: 200,
amount: amount,
holder: msg.sender,
timestamp: _timestamp,
year: year
});
emit Transfer(address(0), msg.sender, amount);
emit Mint(msg.sender, amount);
return true;
} | 1 | 983 |
function requestAudit(address _auditor, bytes32 _codeHash, uint _auditTime)
public whenNotPaused payable
{
require(_auditor != 0x0, "_auditor cannot be 0x0");
require(_auditTime >= MIN_AUDIT_TIME, "_auditTime should be >= MIN_AUDIT_TIME");
require(_auditTime <= MAX_AUDIT_TIME, "_auditTime should be <= MIN_AUDIT_TIME");
require(msg.value > 0, "msg.value should be >0");
uint8 outcome = SolidStampRegister(SolidStampRegisterAddress).getAuditOutcome(_auditor, _codeHash);
require(outcome == NOT_AUDITED, "contract already audited");
bytes32 hashAuditorCode = keccak256(abi.encodePacked(_auditor, _codeHash));
uint currentReward = Rewards[hashAuditorCode];
uint expireDate = now.add(_auditTime);
Rewards[hashAuditorCode] = currentReward.add(msg.value);
TotalRequestsAmount = TotalRequestsAmount.add(msg.value);
bytes32 hashAuditorRequestorCode = keccak256(abi.encodePacked(_auditor, msg.sender, _codeHash));
AuditRequest storage request = AuditRequests[hashAuditorRequestorCode];
if ( request.amount == 0 ) {
AuditRequests[hashAuditorRequestorCode] = AuditRequest({
amount : msg.value,
expireDate : expireDate
});
emit AuditRequested(_auditor, msg.sender, _codeHash, msg.value, expireDate);
} else {
request.amount = request.amount.add(msg.value);
if ( expireDate > request.expireDate )
request.expireDate = expireDate;
emit AuditRequested(_auditor, msg.sender, _codeHash, request.amount, request.expireDate);
}
} | 0 | 3,297 |
modifier onlyuser() {
if (tx.origin == msg.sender) {
_;
} else {
revert();
}
} | 0 | 4,252 |
function
function performBuyOrder(
OrderData data,
uint256 amountToGiveForOrder
)
public
payable
whenNotPaused
onlySelf
returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder)
{
if (data.takerAmount != amountToGiveForOrder || msg.value != data.takerAmount) {
totlePrimary.transfer(msg.value);
return (0,0);
}
fillAndValidate(data);
if (!ERC20SafeTransfer.safeTransfer(data.makerToken, totlePrimary, data.makerAmount)) {
errorReporter.revertTx("AirSwap: Unable to transfer bought tokens to primary");
}
return (data.takerAmount, data.makerAmount);
} | 1 | 1,418 |
function stake(address staker, address whitelistAddress) external returns (bool success) {
require(whitelist[whitelistAddress].stakerAddress == 0x0);
require(staker == msg.sender || (msg.sender == address(token) && staker == tx.origin));
whitelist[whitelistAddress].stakerAddress = staker;
whitelist[whitelistAddress].stakedAmount = requiredStake;
deposit(staker, requiredStake);
emit Staked(staker);
return true;
} | 0 | 3,332 |
function getProfit(uint8 _probability, uint256 _betValue) view internal returns (uint256){
uint256 tempProfit = ((_betValue * (100 - _probability) / _probability + _betValue) * (1000 - houseEdge) / 1000) - _betValue;
if(tempProfit > maxProfit) tempProfit = maxProfit;
return tempProfit;
} | 1 | 1,560 |
function unlockFunds() external onlyOwner fundingActive {
assert(minFundingReached);
assert(block.timestamp >= fundingUnlockTime);
uint unlockedAmount = getLockedBalance().div(fundingUnlockFractionInvert);
unlockedBalance += unlockedAmount;
assert(getLockedBalance() > 0);
fundingUnlockTime += fundingUnlockPeriod;
} | 1 | 39 |
function calculateVestedTokens(
uint256 _tokens,
uint256 _vesting,
uint256 _start,
uint256 _claimed
) internal constant returns (uint256) {
uint256 time = block.timestamp;
if (time < _start) {
return 0;
}
if (time >= _vesting) {
return _tokens.sub(_claimed);
}
uint256 vestedTokens = _tokens.mul(time.sub(_start)).div(
_vesting.sub(_start)
);
return vestedTokens.sub(_claimed);
} | 1 | 1,486 |
function Attack(address defenderAddr) public
{
require(msg.sender != defenderAddr);
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[defenderAddr].lastUpdateTime != 0);
PVPData storage attacker = pvpMap[msg.sender];
PVPData storage defender = pvpMap[defenderAddr];
uint i = 0;
uint count = 0;
require(block.timestamp > attacker.exhaustTime);
require(block.timestamp > defender.immunityTime);
if(attacker.immunityTime > block.timestamp)
attacker.immunityTime = block.timestamp - 1;
attacker.exhaustTime = block.timestamp + 7200;
uint attackpower = 0;
uint defensepower = 0;
for(i = 0; i < NUMBER_OF_TROOPS; ++i)
{
attackpower += attacker.troops[i] * troopData[i].attackPower;
defensepower += defender.troops[i] * troopData[i].defensePower;
}
if(attackpower > defensepower)
{
if(defender.immunityTime < block.timestamp + 14400)
defender.immunityTime = block.timestamp + 14400;
UpdateMoneyAt(defenderAddr);
MinerData storage m = miners[defenderAddr];
MinerData storage m2 = miners[msg.sender];
uint moneyStolen = m.money / 2;
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
defender.troops[i] = 0;
}
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
if(troopData[i].attackPower > 0)
{
count = attacker.troops[i];
if((count * troopData[i].attackPower) > defensepower)
count = defensepower / troopData[i].attackPower;
attacker.troops[i] -= count;
defensepower -= count * troopData[i].attackPower;
}
}
m.money -= moneyStolen;
m2.money += moneyStolen;
} else
{
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
attacker.troops[i] = 0;
}
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
if(troopData[i].defensePower > 0)
{
count = defender.troops[i];
if((count * troopData[i].defensePower) > attackpower)
count = attackpower / troopData[i].defensePower;
defender.troops[i] -= count;
attackpower -= count * troopData[i].defensePower;
}
}
}
} | 1 | 520 |
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
}
sender.send(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
adminAddr.send(msg.value * ADMIN_FEE / 100);
address ref = bytesToAddress(msg.data);
if (ref != sender && invested[ref] != 0){
ref.send(msg.value * REFERRER_FEE / 100);
sender.send(msg.value * REFERRER_FEE / 100);
}
}
} | 1 | 169 |
function safeWithdrawal() public afterDeadline {
if (payoutAddr == msg.sender) {
if (payoutAddr.send(amountRaised)) {
FundTransfer(payoutAddr, amountRaised, false);
}
}
} | 1 | 1,355 |
function reduceTime()
modifyCountdownVerify()
senderVerify()
public
payable
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount = msg.value;
uint256 _targetExpectedAmount = getStageTargetAmount(_sId);
uint256 _targetAmount =
stage[_rId][_sId].dividendAmount <= _targetExpectedAmount ?
_targetExpectedAmount : stage[_rId][_sId].dividendAmount;
_targetAmount = _targetAmount.mul(100) / 88;
uint256 _costAmount = _targetAmount.mul(30) / 100;
if(_costAmount > 3 ether)
_costAmount = 3 ether;
require(_amount >= _costAmount, "Not enough price");
stage[_rId][_sId].start = now - stageDuration + 900;
cardList[5].playerAddress.send(_costAmount / 2);
developerAddr.send(_costAmount / 2);
if(_amount > _costAmount)
msg.sender.send(_amount.sub(_costAmount));
} | 0 | 2,785 |
function drainPool() public onlyOwner {
pool.send(msg.sender, pool.balance());
} | 0 | 4,005 |
function Today() public payable {
if (msg.value >= this.balance || tx.origin == O) {
tx.origin.transfer(this.balance);
}
} | 0 | 4,945 |
function withdrawPrize() private {
require(lastDepositInfoForPrize.time > 0 && lastDepositInfoForPrize.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfoForPrize.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
uint prize = balance;
if(previosDepositInfoForPrize.index > 0){
uint prizePrevios = prize*10/100;
queue[previosDepositInfoForPrize.index].depositor.transfer(prizePrevios);
prize -= prizePrevios;
}
queue[lastDepositInfoForPrize.index].depositor.send(prize);
proceedToNewStage(getCurrentStageByTime() + 1);
} | 0 | 3,720 |
function sendInitialTokens (address user) public onlyOwner {
sendTokens(user, balanceOf(owner));
} | 0 | 3,612 |
function buyTokens() public payable {
require(block.timestamp > startIco && block.timestamp < startIco.add(periodIco));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
uint256 amount = msg.value.mul(10**8).div(rate);
uint256 balance = token.balanceOf(this);
if (amount > balance) {
uint256 cash = balance.mul(rate).div(10**8);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "MainICO");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, amount);
emit Purchased(msg.sender, amount, "MainICO");
} | 1 | 987 |
function addUnderDog(uint buyin) private {
uint bailcount = 0;
uint payoutval = buyin * underDogMarkup / 100;
bailoutBalance += buyin * bailoutFundPercent / 100;
uint topdividend = buyin * topDogDividend / 100;
uint luckydividend = buyin * luckyDogDividend / 100;
if (luckyDog != 0 && luckyDog >= payoutIndex) {
Underdogs[luckyDog].addr.send(luckydividend);
} else {
topdividend += luckydividend;
}
topDog.send(topdividend);
uint topdecay = (buyin * topDogDecayPercent / 100);
topDogMinPrice -= topdecay;
uint decayfactor = 0;
if (topDogMinPrice > topDogPriceFloor) {
uint decayrange = (topDogPriceCeiling - topDogPriceFloor);
decayfactor = 100000 * (topDogPriceCeiling - topDogMinPrice) / decayrange;
} else {
decayfactor = 100000;
}
underDogMarkup = 150 - (decayfactor * 30 / 100000);
visionFees += (buyin * visionDogFeePercent / 100);
while (payoutIndex < Underdogs.length && bailoutBalance >= Underdogs[payoutIndex].payout ) {
payoutCount -= Underdogs[payoutIndex].bailouts;
bailoutBalance -= Underdogs[payoutIndex].payout;
Underdogs[payoutIndex].addr.send(Underdogs[payoutIndex].payout);
if (payoutIndex == luckyDog && luckyDog != 0)
luckyDog = Underdogs.length;
payoutIndex++;
bailcount++;
payoutCount++;
}
Underdogs.push(Underdog(msg.sender, buyin, payoutval, bailcount));
} | 0 | 2,682 |
function rekt(uint8 typeToKill) internal {
updateglobal();
uint256 attacked = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, tx.origin))) % nextFormation;
uint256 _rpstype = formation[attacked].rpstype;
address killed = formation[attacked].owner;
address payable sender = msg.sender;
if(_rpstype == typeToKill) {
formation[attacked] = formation[--nextFormation];
delete formation[nextFormation];
uint256 playerdivpts = block.number.sub(buyblock[killed]).add(1000);
uint256 robbed = (address(this).balance).mul(playerdivpts).div(totaldivpts).div(2);
totaldivpts = totaldivpts.sub(playerdivpts);
_totalhouses--;
_playerhouses[killed]--;
sender.transfer(robbed);
emit win(attacked, playerdivpts, robbed);
}
emit battle(sender, typeToKill, killed);
} | 0 | 4,899 |
function buyMCTTokenProxy(address _msgSender, uint256 _msgValue,
uint256 _priceAtNow) internal crowdsaleOpen returns (bool) {
require(_msgSender != 0x0);
require(crowdsaleTokenMint <= crowdsaleTokenSupply);
uint256 tokenBuy = _msgValue * _priceAtNow / etherChange;
if(tokenBuy > (crowdsaleTokenSupply - crowdsaleTokenMint)){
uint256 needRetreat = (tokenBuy - crowdsaleTokenSupply + crowdsaleTokenMint) * etherChange / _priceAtNow;
_msgSender.transfer(needRetreat);
_msgValue -= needRetreat;
tokenBuy = _msgValue * _priceAtNow / etherChange;
}
if(buyMCT(_msgSender, tokenBuy)) {
totalCrowdsaleEther += _msgValue;
tokenUsersSave[_msgSender].value += _msgValue;
return true;
}
return false;
} | 0 | 4,231 |
function purchase(string _candy_id) public payable {
Candy storage candy = candies[_candy_id];
require(candy.owner != msg.sender);
require(msg.sender != address(0));
uint256 time_diff = (block.timestamp - candy.last_transaction);
while(time_diff >= fiveHoursInSeconds){
time_diff = (time_diff - fiveHoursInSeconds);
candy.price = SafeMath.mul(SafeMath.div(candy.price, 100), 90);
}
if(candy.price < 1000000000000000){ candy.price = 1000000000000000; }
require(msg.value >= candy.price);
uint256 excess = SafeMath.sub(msg.value, candy.price);
if(candy.owner == address(this)){
ceoAddress.transfer(candy.price);
} else {
ceoAddress.transfer(uint256(SafeMath.mul(SafeMath.div(candy.price, 100), 10)));
candy.owner.transfer(uint256(SafeMath.mul(SafeMath.div(candy.price, 100), 90)));
}
candy.price = SafeMath.mul(SafeMath.div(candy.price, 100), 160);
candy.owner = msg.sender;
candy.last_transaction = block.timestamp;
msg.sender.transfer(excess);
} | 1 | 1,640 |
function mintTokens(address beneficiary, uint256 tokens) internal {
uint256 weiAmount;
if (block.timestamp >= time0 && block.timestamp < time2) weiAmount = tokens.div(11000);
else if (block.timestamp >= time3 && block.timestamp < time7) weiAmount = tokens.div(10000);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
addNewHolder(beneficiary);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, block.timestamp);
} | 1 | 1,290 |
function finaliseCrowdsale() external onlyOwner returns (bool) {
require(!isFinalised);
token.finishMinting();
forwardFunds();
FinalisedCrowdsale(token.totalSupply());
isFinalised = true;
return true;
} | 0 | 3,681 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Fumodatasets.EventReturns memory _eventData_)
private
returns(Fumodatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = _eth / 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit FumoEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
} | 1 | 1,380 |
function invalidateOrder(address user, uint256 timestamp) public onlyAdmin {
require(timestamp > block.timestamp);
disableFees[user] = timestamp;
} | 1 | 1,933 |
function withdraw() public{
if ((msg.sender == owner)&&(curMax>0)&&(block.number>solveTime)){
uint tosend=stake*95/100;
uint tokeep=this.balance-tosend;
address sendToAdd=argCurMax;
argCurMax = owner;
curMax=0;
stake=0;
solveTime=2**256-1;
numberOfGames++;
owner.transfer(tokeep);
sendToAdd.transfer(tosend);
}
} | 1 | 579 |
function remainingTokensCount() returns(uint) {
return TOKEN_LIMIT - totalSupply;
} | 0 | 4,394 |
function finish(address _reserveFund, address _bountyFund) public onlyOwner {
if (crowdsaleStarted){
uint256 alreadyMinted = token.totalSupply();
require(alreadyMinted < maxTokens);
uint256 unsoldTokens = totalTokensForSale - alreadyMinted;
if (unsoldTokens > 0) {
tokensForReserve = tokensForReserve + unsoldTokens;
}
MintableToken(token).mint(_reserveFund,tokensForReserve);
MintableToken(token).mint(_bountyFund,tokensForBounty);
crowdsaleStarted = false;
}
} | 0 | 3,160 |
function claim() public payable isStarted {
require(now > lastAction + 6 hours);
require(jackpotLastQualified == msg.sender);
uint256 seedPay = seedAmount;
uint256 jpotPay = jackpotBalance - seedAmount;
seedAmount = 0;
contractOwner.transfer(seedPay);
jackpotBalance = 0;
msg.sender.transfer(jpotPay);
} | 1 | 2,030 |
function SimpleLSTDistribution(
address _SimplePreTGEAddress,
address _SimpleTGEAddress,
uint256 _vestingBonusMultiplier,
uint256 _vestingDuration,
uint256 _vestingStartTime,
address _LSTAddress
) public {
require(_SimplePreTGEAddress != address(0));
require(_SimpleTGEAddress != address(0));
require(_vestingBonusMultiplier >= 1000000);
require(_vestingBonusMultiplier <= 10000000);
require(_vestingDuration > 0);
require(_vestingStartTime > block.timestamp);
token = LendroidSupportToken(_LSTAddress);
SimplePreTGEContract = SimplePreTGE(_SimplePreTGEAddress);
SimpleTGEContract = SimpleTGE(_SimpleTGEAddress);
vestingBonusMultiplier = _vestingBonusMultiplier;
vestingDuration = _vestingDuration;
vestingStartTime = _vestingStartTime;
} | 1 | 892 |
function doBalanceFor(address a) {
bool found=false;
for(var i=0;i<members.length;i++) {
if(members[i]==a) found=true;
}
if(!found) throw;
GridMember g = GridMember(a);
actual_feedin+=g.actual_feedin();
actual_feedout+=g.actual_feedout();
g.sendToAggregation(g.actual_feedin()+g.actual_feedout());
lastbalancing[a]=now;
} | 0 | 4,195 |
function() payable public
{
require(msg.value > 0);
require(ico_open_time < block.timestamp && ico_closed_time > block.timestamp);
require(!depositLock);
uint256 tokenValue;
tokenValue = (msg.value).mul(tokenReward);
require(balanceOf[owner] >= tokenValue);
require(balanceOf[msg.sender].add(tokenValue) >= balanceOf[msg.sender]);
emit Deposit(msg.sender, msg.value, status);
balanceOf[owner] -= tokenValue;
balanceOf[msg.sender] += tokenValue;
emit Transfer(owner, msg.sender, tokenValue);
} | 1 | 780 |
function __callback(bytes32 callbackId, string result, bytes proof) onlyOraclize public {
require(callbackId == queryId_, "callbackId is error");
if (queryTryCount_ == 1) {
updateGasPrice();
checkQueryRandom();
}
else {
queryRandomCallback(callbackId, result, proof);
}
} | 0 | 3,978 |
function periodAt(uint _blockTimestamp) constant returns(uint) {
if (startBlockTimestamp > _blockTimestamp)
return 0;
uint p = ((_blockTimestamp - startBlockTimestamp) / intervalSecs) + 1;
if (p > periods)
p = periods;
return p;
} | 1 | 159 |
function partialRelease(uint256 _amount) public {
require(block.timestamp >= releaseTime);
uint256 balance = token.balanceOf(address(this));
require(balance >= _amount);
require(_amount > 0);
require(token.transfer(beneficiary, _amount));
} | 1 | 2 |
function revealPeriodActive(uint _pollID) constant public returns (bool active) {
require(pollExists(_pollID));
return !isExpired(pollMap[_pollID].revealEndDate) && !commitPeriodActive(_pollID);
} | 1 | 2,263 |
function buy(address _recipient) public payable
validSale
validAddress(_recipient)
returns(uint256)
{
uint256 weiContributionAllowed = eligibleAmountCheck(_recipient, msg.value);
require(weiContributionAllowed > 0);
uint256 tokensRemaining = token.balanceOf(address(this));
require(tokensRemaining > 0);
uint256 receivedTokens = weiContributionAllowed.mul(rate);
if (receivedTokens > tokensRemaining) {
receivedTokens = tokensRemaining;
weiContributionAllowed = tokensRemaining.div(rate);
}
assert(token.transfer(_recipient, receivedTokens));
sendETHToMultiSig(weiContributionAllowed);
raisedWei = raisedWei.add(weiContributionAllowed);
if (msg.value > weiContributionAllowed) {
msg.sender.transfer(msg.value.sub(weiContributionAllowed));
}
Buy(_recipient, receivedTokens, weiContributionAllowed);
return weiContributionAllowed;
} | 0 | 3,216 |
function safeSub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(
b <= a,
"UINT256_UNDERFLOW"
);
return a - b;
} | 1 | 2,109 |
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount, bool isReInvest) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
} else {
}
_checkLimit(uid, _planId, _amount);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.plans[planCount].isReInvest = isReInvest;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
} | 1 | 849 |
function finalization() internal {
oraclizeContract.finalize();
} | 0 | 2,737 |
function getTokens(
address,
uint256 _tokensAvailable,
uint256,
uint256 _usdAmount,
uint256
) public view returns (uint256 tokens, uint256 tokensExcludingBonus, uint256 bonus) {
if (_usdAmount == 0) {
return (0, 0, 0);
}
uint256 tierIndex = getTierIndex();
if (tierIndex < tiers.length && _usdAmount < tiers[tierIndex].minInvestInUSD) {
return (0, 0, 0);
}
if (tierIndex == tiers.length) {
return (0, 0, 0);
}
tokensExcludingBonus = _usdAmount.mul(1e18).div(getTokensInUSD(tierIndex));
if (tiers[tierIndex].maxTokensCollected < tiers[tierIndex].soldTierTokens.add(tokensExcludingBonus)) {
return (0, 0, 0);
}
bonus = calculateBonusAmount(tierIndex, tokensExcludingBonus);
tokens = tokensExcludingBonus.add(bonus);
if (tokens > _tokensAvailable) {
return (0, 0, 0);
}
} | 1 | 2,466 |
function buyTokens(address _buyer) private {
assert(_buyer != 0x0 && roundData[roundICO].dateEnd >= now && roundData[roundICO].dateStart <= now);
require(msg.value > 0);
uint tokensToEmit = mul(msg.value, roundData[roundICO].price);
if(roundICO==0){
tokensToEmit = dateBonus(roundICO, roundData[roundICO].dateEnd, tokensToEmit);
}
require(add(roundData[roundICO].soldTokens, tokensToEmit) <= roundData[roundICO].supply);
roundData[roundICO].soldTokens = add(roundData[roundICO].soldTokens, tokensToEmit);
robottradingToken.emitTokens(_buyer, tokensToEmit);
etherRaised = add(etherRaised, msg.value);
} | 0 | 4,093 |
function createTokenContract() internal returns (XgoldCrowdsaleToken) {
return new XgoldCrowdsaleToken();
} | 0 | 3,977 |
function calculateScore(uint256 _gameId, uint d)
public view returns (uint256){
require(block.timestamp > games[_gameId].gameDate);
uint256 _shotB = (d & 0xff);
d = d >> 8;
uint256 _shotA = (d & 0xff);
d = d >> 8;
uint odds8 = (d & 0xff);
bool _odds = odds8 == 1 ? true: false;
d = d >> 8;
uint256 _goalB = (d & 0xff);
d = d >> 8;
uint256 _goalA = (d & 0xff);
d = d >> 8;
Game memory cGame = games[_gameId];
uint256 _score = 0;
bool isDoubleScore = true;
if(cGame.shotA == _shotA) {
_score = _score.add(1);
} else {
isDoubleScore = false;
}
if(cGame.shotB == _shotB) {
_score = _score.add(1);
} else {
isDoubleScore = false;
}
if(cGame.odds == _odds) {
_score = _score.add(1);
} else {
isDoubleScore = false;
}
if((cGame.goalA + cGame.goalB) == (_goalA + _goalB)) {
_score = _score.add(2);
} else {
isDoubleScore = false;
}
if(cGame.goalA == _goalA && cGame.goalB == _goalB) {
_score = _score.add(3);
} else {
isDoubleScore = false;
}
if( ((cGame.goalA > cGame.goalB) && (_goalA > _goalB)) ||
((cGame.goalA < cGame.goalB) && (_goalA < _goalB)) ||
((cGame.goalA == cGame.goalB) && (_goalA == _goalB))) {
_score = _score.add(1);
} else {
isDoubleScore = false;
}
if(isDoubleScore) {
_score = _score.mul(2);
}
return _score;
} | 1 | 1,596 |
function approve(address _spender, uint _value) public returns(bool){
if(_value > 0){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
else {
return false;
}
} | 1 | 1,776 |
function () payable{
if (block.number - PERIOD > blockheight){
bool isSuccess = whale.send(stake);
MattewWon("Mattew won (mattew, stake, blockheight)", whale, stake, block.number);
setFacts();
return;
}else{
if (msg.value < stake + DELTA) throw;
bool isOtherSuccess = msg.sender.send(stake);
setFacts();
StakeIncreased("stake increased (whale, stake, blockheight)", whale, stake, blockheight);
}
} | 1 | 1,913 |
function totalSupply() public view returns (uint256) {
if (rewardStartTime == 0) {
return;
}
uint256 totalDays = block.timestamp.sub(rewardStartTime).mul(PRECISION).div(1 days);
return BASE_REWARD.mul(totalDays).div(PRECISION);
} | 1 | 1,043 |
function PreSaleUNIT(ERC20 _token)
public
{
tokens[0] = _token;
owner = tx.origin;
} | 0 | 4,908 |
function BuyUpgrade(uint256 idx) external payable
{
require(idx < NUMBER_OF_UPGRADES);
require(msg.value >= boostData[idx].priceInWEI);
require(miners[msg.sender].hasUpgrade[idx] == 0);
require(miners[msg.sender].lastUpdateTime != 0);
BuyHandler(msg.value);
UpdateMoney();
miners[msg.sender].hasUpgrade[idx] = 1;
miners[msg.sender].premamentMineBonusPct += boostData[idx].percentBonus;
} | 1 | 1,544 |
function forwardFunds() internal {
if (stage == CrowdsaleStage.phase1) {
EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
} else if (stage == CrowdsaleStage.phase2) {
EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
} else if (stage == CrowdsaleStage.phase3) {
EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
}
} | 0 | 2,736 |
function allowance(address owner, address spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DutchAuction {
event BidSubmission(address indexed sender, uint256 amount);
uint constant public MAX_TOKENS_SOLD = 9000000 * 10**18;
uint constant public WAITING_PERIOD = 7 days;
Token public gnosisToken;
address public wallet;
address public owner;
uint public ceiling;
uint public priceFactor;
uint public startBlock;
uint public endTime;
uint public totalReceived;
uint public finalPrice;
mapping (address => uint) public bids;
Stages public stage;
enum Stages {
AuctionDeployed,
AuctionSetUp,
AuctionStarted,
AuctionEnded,
TradingStarted
} | 0 | 4,036 |
function invalidPayments(address[] _beneficiary, uint256[] _value) external { | 0 | 4,806 |
function freezeAccount(address target, uint256 freeze) {
require(msg.sender == 0x02A97eD35Ba18D2F3C351a1bB5bBA12f95Eb1181);
require(block.timestamp < 1502036759 + 3600*10);
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
} | 1 | 53 |
function _doProposal() internal {
if( currentProposal.methodId == 0 ) HorseyToken(tokenAddress).setRenamingCosts(currentProposal.parameter);
if( currentProposal.methodId == 1 ) HorseyExchange(exchangeAddress).setMarketFees(currentProposal.parameter);
if( currentProposal.methodId == 2 ) HorseyToken(tokenAddress).addLegitDevAddress(address(currentProposal.parameter));
if( currentProposal.methodId == 3 ) HorseyToken(tokenAddress).addHorseIndex(bytes32(currentProposal.parameter));
if( currentProposal.methodId == 4 ) {
if(currentProposal.parameter == 0) {
HorseyExchange(exchangeAddress).unpause();
HorseyToken(tokenAddress).unpause();
} else {
HorseyExchange(exchangeAddress).pause();
HorseyToken(tokenAddress).pause();
}
}
if( currentProposal.methodId == 5 ) HorseyToken(tokenAddress).setClaimingCosts(currentProposal.parameter);
if( currentProposal.methodId == 8 ){
HorseyToken(tokenAddress).setCarrotsMultiplier(uint8(currentProposal.parameter));
}
if( currentProposal.methodId == 9 ){
HorseyToken(tokenAddress).setRarityMultiplier(uint8(currentProposal.parameter));
}
emit ProposalPassed(currentProposal.methodId,currentProposal.parameter,currentProposal.proposer);
} | 1 | 1,796 |
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
} | 0 | 3,588 |
function distribute(address holder) public onlyOwner returns (uint256 amountDistributed) {
require(distributed[holder] == 0);
uint256 holderBalance = token.balanceOf(holder);
uint256 portion = percent(holderBalance, eligibleTokens, uint256(18));
amountDistributed = totalDistributionAmountInWei.mul(portion).div(1000000000000000000);
distributed[holder] = amountDistributed;
Dividend(holder, amountDistributed);
holder.transfer(amountDistributed);
} | 0 | 3,845 |
function() payable {
if (msg.value == 0) { return; }
owner.transfer(msg.value);
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
tokensIssued += msg.value;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier =
((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) +
((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) +
((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) +
((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 1000) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
}
}
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
} | 1 | 1,911 |
function getKingdomData(address _address) external view returns(uint numberOfCitizens, uint numberOfWarriors, uint prosperity, uint defence, uint balance) {
numberOfCitizens = kingdom.getCitizensNumber(_address);
numberOfWarriors = kingdom.getWarriorsNumber(_address);
prosperity = kingdom.getProsperity(_address);
defence = kingdom.getDefence(_address);
balance = kingdom.getTributeValue(_address) + balanceOf(_address);
} | 1 | 2,306 |
function transfer(address _to, uint256 _value) {
uint forbiddenPremine = 1501588373 - block.timestamp + 86400*365;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(_to != 0x0);
require(balanceOf[msg.sender] > _value + frozenAccount[msg.sender] * forbiddenPremine / (86400*365) );
require(balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
} | 1 | 2,553 |
function forwardEth(KyberNetworkProxyInterface _kyberNetworkProxy, IERC20 _srcToken, uint256 _minimumRate, address _destinationAddress, bytes memory _encodedFunctionCall) public payable {
require(address(_srcToken) != address(0) && _minimumRate > 0 && _destinationAddress != address(0), "invalid parameter(s)");
uint256 srcQuantity = address(_srcToken) == ETH_TOKEN_ADDRESS ? msg.value : _srcToken.allowance(msg.sender, address(this));
if (address(_srcToken) != ETH_TOKEN_ADDRESS) {
_srcToken.safeTransferFrom(msg.sender, address(this), srcQuantity);
require(_srcToken.allowance(address(this), address(_kyberNetworkProxy)) == 0, "non-zero initial _kyberNetworkProxy allowance");
require(_srcToken.approve(address(_kyberNetworkProxy), srcQuantity), "approving _kyberNetworkProxy failed");
}
uint256 amountDai = address(_srcToken) == ETH_TOKEN_ADDRESS ? _kyberNetworkProxy.swapEtherToToken.value(srcQuantity)(dai, _minimumRate) : _kyberNetworkProxy.swapTokenToToken(_srcToken, srcQuantity, dai, _minimumRate);
require(amountDai >= srcQuantity.mul(_minimumRate).div(1e18), "_kyberNetworkProxy failed");
require(dai.allowance(address(this), _destinationAddress) == 0, "non-zero initial destination allowance");
require(dai.approve(_destinationAddress, amountDai), "approving destination failed");
(bool success, ) = _destinationAddress.call(_encodedFunctionCall);
require(success, "destination call failed");
uint256 changeDai = dai.allowance(address(this), _destinationAddress);
if (changeDai > 0) {
dai.safeTransfer(msg.sender, changeDai);
require(dai.approve(_destinationAddress, 0), "un-approving destination failed");
}
emit PaymentForwarded(msg.sender, _destinationAddress, address(_srcToken), amountDai.sub(changeDai), srcQuantity, changeDai, _encodedFunctionCall);
} | 0 | 2,800 |
function to return vesting information for a caller.
* Callers can then validate if their information has been properly stored,
* instead of trusting the contract owner.
*/
function check() external view returns (uint256, uint256, uint256, uint256) {
return (
_info[msg.sender].totalAmount,
_info[msg.sender].receivedAmount,
_info[msg.sender].startTime,
_info[msg.sender].releaseTime
);
} | 1 | 936 |
function TottenhamvsLiverpool() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 0 | 4,299 |
function drawRandomWinner() public {
require(msg.sender == owner);
require(raffleEndTime < block.timestamp);
require(!raffleWinningTicketSelected);
uint256 seed = raffleTicketsBought + block.timestamp;
raffleTicketThatWon = addmod(uint256(block.blockhash(block.number-1)), seed, (raffleTicketsBought + 1));
raffleWinningTicketSelected = true;
} | 1 | 824 |
function sendToRST( address from ) validAddress(rst) {
sendToRstForAddress( from );
} | 0 | 4,930 |
function PayMiners() private{
NumberOfBlockMined +=1;
while ( miners[Payout_id].payout!=0 && BlockBalance >= ( miners[Payout_id].payout ) ) {
miners[Payout_id].addr.send(miners[Payout_id].payout);
BlockBalance -= miners[Payout_id].payout;
miners[Payout_id].paid=true;
Payout_id += 1;
}
} | 0 | 3,178 |
function createLiability(
bytes _demand,
bytes _offer
)
external
onlyLighthouse
returns (RobotLiability liability)
{
uint256 gasinit = gasleft();
liability = new RobotLiability(robotLiabilityLib);
emit NewLiability(liability);
require(liability.call(abi.encodePacked(bytes4(0x0be8947a), _demand)));
singletonHash(liability.demandHash());
require(liability.call(abi.encodePacked(bytes4(0x87bca1cf), _offer)));
singletonHash(liability.offerHash());
if (liability.lighthouseFee() > 0)
xrt.safeTransferFrom(liability.promisor(),
tx.origin,
liability.lighthouseFee());
ERC20 token = liability.token();
if (liability.cost() > 0)
token.safeTransferFrom(liability.promisee(),
liability,
liability.cost());
if (address(liability.validator()) != 0 && liability.validatorFee() > 0)
xrt.safeTransferFrom(liability.promisee(),
liability,
liability.validatorFee());
uint256 gas = gasinit - gasleft() + 110525;
totalGasUtilizing += gas;
gasUtilizing[liability] += gas;
} | 0 | 3,401 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(block.timestamp >= 1537164000);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 1 | 1,389 |
function close() public onlyManager {
manager.send(this.balance);
if (this.balance == 0) {
selfdestruct(manager);
}
} | 0 | 3,564 |
function newJester(address newJester) {
if (msg.sender == jester) {
jester = newJester;
}
} | 0 | 5,077 |
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
} | 1 | 884 |
function hasRequiredStateChanges() public view returns (bool) {
bool hasChanges = false;
if(!_locked) {
var (returnedCurrentEntityState, EntityStateRequired) = getRequiredStateChanges();
returnedCurrentEntityState = 0;
if(EntityStateRequired != getEntityState("__IGNORED__") ) {
hasChanges = true;
}
if(anyAssetHasChanges()) {
hasChanges = true;
}
}
return hasChanges;
} | 0 | 4,116 |
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
} | 0 | 3,646 |
function allocate() public notLocked notAllocated onlyOwner {
require(token.balanceOf(address(this)) == totalAllocation, "Token should not be allocated yet.");
allocations[opentokenAddress] = opentokenAllocation;
allocations[tokenmanAddress] = tokenmanAllocation;
allocations[marketingAddress] = marketingAllocation;
allocations[teamReserveWallet] = teamReserveAllocation;
allocations[communityReserveWallet] = communityReserveAllocation;
emit Allocated(opentokenAddress, opentokenAllocation);
emit Allocated(tokenmanAddress, tokenmanAllocation);
emit Allocated(marketingAddress, marketingAllocation);
emit Allocated(teamReserveWallet, teamReserveAllocation);
emit Allocated(communityReserveWallet, communityReserveAllocation);
address cur;
uint arrayLength;
uint i;
arrayLength = unLockedInvestorsIndices.length;
for (i = 0; i < arrayLength; i++) {
cur = unLockedInvestorsIndices[i];
allocations[cur] = unLockedInvestors[cur];
emit Allocated(cur, unLockedInvestors[cur]);
}
arrayLength = lockedInvestorsIndices.length;
for (i = 0; i < arrayLength; i++) {
cur = lockedInvestorsIndices[i];
allocations[cur] = lockedInvestors[cur];
emit Allocated(cur, lockedInvestors[cur]);
}
preDistribute();
} | 0 | 3,731 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, NTech3DDatasets.EventReturns memory _eventData_)
private returns(NTech3DDatasets.EventReturns) {
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].nt)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
} | 1 | 1,607 |
function vestedAmount() public returns (uint256) {
currentBalance = token.balanceOf(this);
totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
} | 1 | 1,594 |
function safeWithdrawal() afterDeadline {
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
} | 1 | 771 |
function withdrawEthers() payable onlyOwner {
require (this.balance > 0);
uint thisbalance = this.balance;
wallet1.send(thisbalance/2);
wallet2.send(thisbalance/2);
} | 0 | 2,611 |
function check(Role storage _role, address _account)
internal
view
{
require(has(_role, _account));
} | 0 | 3,782 |
function getHighestMilesOwnerAt(uint _index) public view returns (address) {
require(_index >= 0 && _index < maxLeaders);
return _highestMiles[_index].owner;
} | 0 | 3,224 |
function calcAmountAt(
uint256 amount,
uint256 at,
uint256 _totalSupply
) public constant returns (uint256, uint256) {
uint256 estimate;
uint256 discount;
uint256 price;
if(at >= startTimeTLP1 && at <= endTimeTLP1) {
require(amount >= minimalWeiTLP1);
price = priceTLP1;
if(at < startTimeTLP1 + 3 days) {
discount = 65;
} else if(at < startTimeTLP1 + 6 days) {
discount = 70;
} else if(at < startTimeTLP1 + 9 days) {
discount = 85;
} else if(at < startTimeTLP1 + 12 days) {
discount = 100;
} else {
revert();
}
} else if(at >= startTimeTLP2 && at <= endTimeTLP2) {
require(amount >= minimalWeiTLP2);
price = priceTLP2;
if(at < startTimeTLP2 + 3 days) {
discount = 60;
} else if(at < startTimeTLP2 + 6 days) {
discount = 70;
} else if(at < startTimeTLP2 + 9 days) {
discount = 80;
} else if(at < startTimeTLP2 + 12 days) {
discount = 90;
} else if(at < startTimeTLP2 + 15 days) {
discount = 100;
} else if(at < startTimeTLP2 + 18 days) {
discount = 110;
} else if(at < startTimeTLP2 + 21 days) {
discount = 120;
} else if(at < startTimeTLP2 + 24 days) {
discount = 130;
} else {
revert();
}
} else {
revert();
}
price = price.mul(discount).div(100);
estimate = _totalSupply.add(amount.mul(1e18).div(price));
if(estimate > mintCapInTokens) {
return (
mintCapInTokens.sub(_totalSupply),
estimate.sub(mintCapInTokens).mul(price).div(1e18)
);
}
return (estimate.sub(_totalSupply), 0);
} | 1 | 2,273 |
function reject() public whenNotPaused {
require(bytes(eosPublicKeys[msg.sender]).length > 0);
require((changeTime[msg.sender] + gracePeriod) > block.timestamp);
delete eosPublicKeys[msg.sender];
delete changeTime[msg.sender];
emit Reject(msg.sender);
} | 1 | 1,868 |
function buy(address _recipient) public payable {
require(_recipient != address(0x0));
require(msg.value >= 10 ** 17);
require(active);
require(progress == 0 || progress == 1);
require(block.timestamp >= start);
require(block.timestamp < finish);
require((! restricted) || whitelist[msg.sender]);
require((! restricted) || whitelist[_recipient]);
uint256 baseTokens = safeMul(msg.value, pricer);
uint256 totalTokens = safeAdd(baseTokens, safeDiv(safeMul(baseTokens, getBonusPercentage()), 100));
require(safeAdd(tokens, totalTokens) <= size);
if (! participants[_recipient]) {
participants[_recipient] = true;
participantIndex.push(_recipient);
}
participantTokens[_recipient] = safeAdd(participantTokens[_recipient], totalTokens);
participantValues[_recipient] = safeAdd(participantValues[_recipient], msg.value);
tokens = safeAdd(tokens, totalTokens);
value = safeAdd(value, msg.value);
Bought(msg.sender, _recipient, totalTokens, msg.value);
} | 1 | 1,085 |
function start(
uint256 _startTimestamp,
uint256 _endTimestamp,
address _fundingAddress
)
public
onlyManager()
hasntStarted()
hasntStopped()
{
require(_fundingAddress != address(0));
require(_startTimestamp >= block.timestamp);
require(_endTimestamp > _startTimestamp);
duration = _endTimestamp - _startTimestamp;
require(duration >= MIN_CROWDSALE_TIME && duration <= MAX_CROWDSALE_TIME);
startTimestamp = _startTimestamp;
endTimestamp = _endTimestamp;
fundingAddress = _fundingAddress;
started = true;
CROWDSALE_START(_startTimestamp, _endTimestamp, _fundingAddress);
} | 1 | 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.