func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function hasEnded() public constant returns (bool) {
if (currentTime() > endTimestamp)
return true;
if (tokenRaised >= tokensForSale)
return true;
return false;
} | 0 | 4,522 |
function removeAllTournamentContenders() external onlyOwner TournamentPaused {
uint256 length = tournamentQueueSize;
uint256 warriorId;
uint256 failedBooty;
uint256 i;
uint256 fee;
uint256 bank = currentTournamentBank;
uint256[] memory warriorsData = new uint256[](length);
for(i = 0; i < length; i ++) {
warriorsData[i] = tournamentQueue[i * DATA_SIZE];
}
pvpListener.tournamentFinished(warriorsData);
currentTournamentBank = 0;
tournamentQueueSize = 0;
for(i = length - 1; i >= 0; i --) {
warriorId = CryptoUtils._unpackWarriorId(warriorsData[i], 0);
fee = bank - (bank * 10000 / (tournamentEntranceFeeCut * (10000 - THRESHOLD) / 10000 + 10000));
failedBooty += sendBooty(warriorToOwner[warriorId], fee);
bank -= fee;
}
currentTournamentBank = bank;
totalBooty += failedBooty;
} | 0 | 3,197 |
function burn(uint256 _value, uint256 _confirmation) onlyOwner public returns (bool success) {
require(_confirmation==7007);
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
} | 0 | 3,841 |
function transferFromAt(address _from, address _to, uint256 _value) public returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
require(block.timestamp > timeLock[_from][msg.sender]);
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 | 2,576 |
function setAccountAllowance(address from, address to, uint256 amount) onlyOwnerUnlocked {
allowance[from][to] = amount;
activateAllowanceRecord(from, to);
} | 0 | 4,527 |
function safeWithdrawal() public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
} | 1 | 1,457 |
function () public payable {
require(!isContract(msg.sender));
if(msg.value == verificationPrice) {
verify(msg.sender);
return;
}
if (msg.value == 0 && msg.sender == owner()) {
address a = bytesToAddress(bytes(msg.data));
verify(a);
return;
}
if (referrer[msg.sender] == address(0)) {
require(setRef());
}
if(msg.value > 0){
require(gasleft() >= 300000, "We require more gas!");
require(msg.value <= 10 ether);
if (block.timestamp >= cycleStart + actualCycle) {
if (queue.length.sub(lastCycle) < frontier) {
actualCycle = actualCycle * 2;
if (actualCycle > maxCycle) {
actualCycle = maxCycle;
}
} else {
actualCycle = actualCycle / 2;
if (actualCycle < minCycle) {
actualCycle = minCycle;
}
}
uint amountOfPlayers = queue.length - lastCycle;
lastCycle = queue.length;
cycleStart = block.timestamp;
currentReceiverIndex = lastCycle;
cycles++;
if (amountOfPlayers != 1) {
currentRefundIndex = lastCycle.sub(1);
refunding();
} else {
singleRefunding();
}
emit NewCycle(cycleStart, actualCycle, cycles);
}
if (currentRefundIndex != 0) {
refunding();
}
uint percent = queue.length.sub(lastCycle).add(1);
if (percent >= 33) {
percent = 33;
}
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value * (100 + percent) / 100)));
uint _support = msg.value * supportPercent / 100;
support.send(_support);
uint _refBonus = msg.value * refBonus / 1000;
referrer[msg.sender].send(_refBonus);
emit RefBonusPayed(msg.sender, referrer[msg.sender], _refBonus, 1);
if (referrer[referrer[msg.sender]] != address(0)) {
referrer[referrer[msg.sender]].send(_refBonus);
emit RefBonusPayed(msg.sender, referrer[referrer[msg.sender]], _refBonus, 2);
}
emit NewDeposit(msg.sender, queue.length - 1, msg.value, msg.value * (100 + percent) / 100, cycles);
if (currentRefundIndex == 0) {
reserved += msg.value * 96 / 100 / 2;
if (delayed != 0) {
reserved != delayed;
delayed = 0;
}
pay();
} else {
delayed += msg.value * 96 / 100 / 2;
}
}
} | 1 | 1,395 |
function getAccumulatedDistributionPercentage() public constant returns(uint256 percentage) {
uint256 period = getCurrentPeriodIndex();
assert(period < totalPeriods);
return periods[period];
} | 1 | 264 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
updateInheritedEarlyParticipantWhitelist(receiver, tokenAmount);
} else {
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
} | 0 | 3,291 |
function activateConflictResolution() public onlyOwner {
require(newConflictRes != 0);
require(updateTime != 0);
require(updateTime + MIN_TIMEOUT <= block.timestamp && block.timestamp <= updateTime + MAX_TIMEOUT);
conflictRes = ConflictResolutionInterface(newConflictRes);
newConflictRes = 0;
updateTime = 0;
LogUpdatedConflictResolution(newConflictRes);
} | 1 | 929 |
function getBlockHeader(int blockHash) returns (bytes32[3]);
}
contract Lottery {
int constant LOTTERY_BLOCKS = 7 * 24 * 6;
uint constant LOTTERY_INTERVAL = 7 days;
int constant CUTOFF_BLOCKS = 6 * 6;
uint constant CUTOFF_INTERVAL = 6 hours;
uint constant TICKET_PRICE = 10 finney;
uint constant FEE_FACTOR = 200;
BTCRelay btcRelay = BTCRelay(0x41f274c0023f83391de4e0733c609df5a124c3d4);
struct Bucket {
uint numHolders;
address[] ticketHolders;
} | 0 | 3,334 |
function () public payable {
if (msg.sender == owner) {
return;
}
if (msg.value > 0) {
uint mfee = (2 * msg.value) / 100;
if (address(this).balance >= mfee) {
if (address(this).balance >= (mfee + maintenanceDebt) ) {
owner.transfer(mfee + maintenanceDebt);
maintenanceDebt = 0;
} else {
owner.transfer(mfee);
}
} else {
maintenanceDebt += mfee;
}
uint tokenAmount = tokensPerEthereum * msg.value;
if (tokenAmount > 0) {
require( (balanceOf[msg.sender] + tokenAmount) > balanceOf[msg.sender]);
payBonus(msg.sender);
payInterest(msg.sender);
balanceOf[msg.sender] += tokenAmount;
totalSupply += tokenAmount;
Transfer(this, msg.sender, tokenAmount);
depositTotal[msg.sender] += msg.value;
string memory ats = addressToString(msg.sender);
current_jackpot_hash = keccak256(current_jackpot_hash, ats, block.coinbase, block.number, block.timestamp);
uint diffx = hashDifficulty(current_jackpot_hash);
if (diffx >= jackpotDifficulty) {
Jackpot(msg.sender, address(this).balance);
msg.sender.transfer(address(this).balance);
}
GameResult(msg.sender, diffx);
}
}
} | 1 | 2,470 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 currentRate = rate;
if (block.timestamp < presaleEndTime) {
currentRate = presaleRate;
}
else if (hardCap > 0 && weiRaised > hardCap) {
currentRate = postHardRate;
}
else if (weiRaised > softCap) {
currentRate = postSoftRate;
}
uint256 tokens = weiAmount.mul(currentRate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 1 | 2,178 |
function takeCapital() public{
require(capitalAmount_>0 && AdminRewardAmount_>0, "No fundz, sorry!");
uint256 capitalAmountTrans=capitalAmount_;
uint256 adminAmountTrans=AdminRewardAmount_;
capitalAmount_=0;
AdminRewardAmount_=0;
capital_.call.value(capitalAmountTrans)();
DevsInterface devContract_ = DevsInterface(devReward_);
devContract_.payDividends.value(adminAmountTrans)('ethedge.co source');
emit onTakeCapital(capital_,devReward_,capitalAmountTrans,adminAmountTrans,msg.sender,now);
} | 0 | 3,697 |
function allocateFounderTokens() public onlyAdmin {
require( block.timestamp > endDatetime );
require(!founderAllocated);
balances[founder] = balances[founder].add(founderAllocation);
totalSupply_ = totalSupply_.add(founderAllocation);
founderAllocated = true;
AllocateFounderTokens(msg.sender, founder, founderAllocation);
} | 1 | 246 |
function _forward(address _to, bytes _data) internal returns(bool) {
uint startGas = msg.gas + forwardCallGas + (_data.length * 50);
if (_to == 0x0) {
return false;
}
_to.call.value(msg.value)(_data);
return _applyRefund(startGas);
} | 0 | 3,912 |
function withdrawRemainingBalanceForManualRecovery() onlyOwner public {
require(this.balance != 0);
require(block.timestamp > crowdsaleEndedTime);
require(contributorIndexes[nextContributorToClaim] == 0x0);
multisigAddress.transfer(this.balance);
} | 1 | 1,758 |
{
require(!deactivated);
require(_amountST > 0);
require(valueToken.allowance(tx.origin, address(this)) >= _amountST);
require(utilityTokens[_uuid].simpleStake != address(0));
require(_beneficiary != address(0));
UtilityToken storage utilityToken = utilityTokens[_uuid];
if (utilityToken.stakingAccount != address(0)) require(msg.sender == utilityToken.stakingAccount);
require(valueToken.transferFrom(tx.origin, address(this), _amountST));
amountUT = (_amountST.mul(utilityToken.conversionRate))
.div(10**uint256(utilityToken.conversionRateDecimals));
unlockHeight = block.number + blocksToWaitLong();
nonces[tx.origin]++;
nonce = nonces[tx.origin];
stakingIntentHash = hashStakingIntent(
_uuid,
tx.origin,
nonce,
_beneficiary,
_amountST,
amountUT,
unlockHeight
);
stakes[stakingIntentHash] = Stake({
uuid: _uuid,
staker: tx.origin,
beneficiary: _beneficiary,
nonce: nonce,
amountST: _amountST,
amountUT: amountUT,
unlockHeight: unlockHeight
});
StakingIntentDeclared(_uuid, tx.origin, nonce, _beneficiary,
_amountST, amountUT, unlockHeight, stakingIntentHash, utilityToken.chainIdUtility);
return (amountUT, nonce, unlockHeight, stakingIntentHash);
} | 0 | 5,065 |
function VerifiedInfoHash(bytes32 hash) public view notBlocked returns(bool) {
return VerifiedInfoHashes[hash];
} | 0 | 3,392 |
function finalizeHodler() public returns (bool) {
require(msg.sender == admin);
require(block.timestamp >= hodlerTimeStart.add( 450 days ) );
uint256 amount = tokenContract.balanceOf(this);
require(amount > 0);
if (istransferringTokens == false) {
istransferringTokens = true;
require(tokenContract.transfer(admin,amount));
istransferringTokens = false;
return true;
}
return false;
} | 1 | 923 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require(withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require(jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
} | 0 | 3,181 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _long = _eth / 50;
if(_long > 0)
swapDeposit.transfer(_long);
uint256 _p3d;
if (!address(Team_Forwarder).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != "") {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
if(!address(Team_Forwarder).call.value(_p3d)(bytes4(keccak256("deposit()"))))
{
uint256 __rID = rID_ + 1;
round_[__rID].pot = round_[__rID].pot.add(_p3d);
}
_p3d = 0;
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 268 |
function withdraw() public {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(msg.sender) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(msg.sender); i++) {
if (x.w(msg.sender, i) < x.d(msg.sender, i) * 2) {
if (x.s(msg.sender, i) <= x.c(msg.sender)) {
uint dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.c(msg.sender).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
if (x.s(msg.sender, i) + 2 days >= block.timestamp) {
dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
dividends = (x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i))).div(1 days);
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
}
}
}
}
if (_payout > 0) {
if (_payout > address(this).balance && address(this).balance <= 0.1 ether) {
nextWave();
return;
}
x.updateCheckpoint(msg.sender);
advertising.transfer(_payout * 3 / 25);
techsupport.transfer(_payout * 3 / 100);
msg.sender.transfer(_payout * 17 / 20);
emit LogPayment(msg.sender, _payout * 17 / 20);
}
if (block.timestamp >= lastLeader + 1 days && top.length >= 5) {
payDay();
}
} | 1 | 669 |
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
} | 0 | 4,997 |
function _unfreezeMaxTokens(uint _value) internal {
uint amount = frozenBalanceOf[msg.sender] > _value ? _value : frozenBalanceOf[msg.sender];
if (amount > 0) {
balanceOf[msg.sender] += amount;
frozenBalanceOf[msg.sender] -= amount;
Transfer(this, msg.sender, amount);
}
} | 1 | 1,910 |
function getBonus() {
address sender = msg.sender;
require(bonuses[sender] > 0);
require(bonusUnlockTime[sender]!=0 &&
now > bonusUnlockTime[sender]);
tokenReward.transfer(sender, bonuses[sender]);
bonuses[sender] = 0;
} | 0 | 4,200 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 1 | 1,152 |
function getBetsByCategory(bytes32 category) view public returns (Bet[]) {
return bets[category];
} | 0 | 5,016 |
function withdraw() external {
address participant = msg.sender;
uint256 tokens = withdrawals[participant].tokens;
require(tokens > 0);
uint256 requestTime = withdrawals[participant].time;
Price price = prices[requestTime];
require(price.numerator > 0);
uint256 withdrawValue = safeMul(tokens, price.denominator) / price.numerator;
withdrawals[participant].tokens = 0;
if (this.balance >= withdrawValue)
enact_withdrawal_greater_equal(participant, withdrawValue, tokens);
else
enact_withdrawal_less(participant, withdrawValue, tokens);
} | 0 | 3,764 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Valid address is required");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 | 4,416 |
function list_frozen_accounts(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _frozen_holders,uint[] _whens){
uint len = holders_frozen.length;
uint num_of_frozen_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if( account_frozen_time[ holders_frozen[i] ] > 0x0) num_of_frozen_holders++;
if(_max_num_of_items_to_display == num_of_frozen_holders) break;
}
_frozen_holders = new address[](num_of_frozen_holders);
_whens = new uint[](num_of_frozen_holders);
_num=0;
for (uint j = len-1 ; j >= 0 && num_of_frozen_holders > _num ; j--) {
address addr= holders_frozen[j];
uint256 when= account_frozen_time[ addr ];
if( when == 0x0) continue;
_frozen_holders[_num]= addr;
_whens[_num]= when;
_num++;
}
} | 1 | 1,781 |
constructor(
ERC20Basic _token,
address _beneficiary
)
public
{
require(block.timestamp < releaseTime1);
require(block.timestamp < releaseTime2);
require(block.timestamp < releaseTime3);
require(block.timestamp < releaseTime4);
require(_beneficiary != address(0));
require(_token != address(0));
token = _token;
beneficiary = _beneficiary;
} | 1 | 2,307 |
function buyTokens(address beneficiary) public payable {
transStartTime=now;
require(goldList[beneficiary]||kycAcceptedList[beneficiary]);
goldListPeriodFlag=false;
require(beneficiary != address(0));
require(validPurchase());
uint256 extraEth=0;
weiAmount = msg.value;
if((msg.value>ethCap.sub(mainWeiRaised)) && !goldListPeriodFlag){
weiAmount=ethCap.sub(mainWeiRaised);
extraEth=(msg.value).sub(weiAmount);
}
tokens = getTokenAmount(weiAmount);
mainWeiRaised = mainWeiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
mainContribution[beneficiary] = mainContribution[beneficiary].add(weiAmount);
if(goldListPeriodFlag){
goldListContribution[beneficiary] = goldListContribution[beneficiary].add(weiAmount);
}
TokenPurchase(beneficiary, weiAmount, tokens);
forwardFunds();
if(extraEth>0){
beneficiary.transfer(extraEth);
}
} | 0 | 3,478 |
function doStateChanges() public {
var (CurrentRecordState, RecordStateRequired, EntityStateRequired) = getRequiredStateChanges();
bool callAgain = false;
DebugRecordRequiredChanges( assetName, CurrentRecordState, RecordStateRequired );
DebugEntityRequiredChanges( assetName, CurrentEntityState, EntityStateRequired );
if( RecordStateRequired != getRecordState("__IGNORED__") ) {
RecordProcessor(CurrentRecordState, RecordStateRequired);
DebugCallAgain(2);
callAgain = true;
}
if(EntityStateRequired != getEntityState("__IGNORED__") ) {
EntityProcessor(EntityStateRequired);
DebugCallAgain(1);
callAgain = true;
}
} | 0 | 3,245 |
function withdraw() public auth {
require(this.balance > 0);
require(block.timestamp >= endTime + 3600 * 24 * 30 * 3);
owner.transfer(this.balance);
} | 1 | 1,915 |
function getCurrentFgcCap() public constant returns (uint) {
if (block.timestamp < startsAt)
return maxEthPerAddress;
uint timeSinceStart = block.timestamp.sub(startsAt);
uint currentPeriod = timeSinceStart.div(TIME_PERIOD_IN_SEC).add(1);
if (currentPeriod < 2) {
return 5000 * 10**token.decimals();
}
if (currentPeriod > 2 && currentPeriod < 5) {
return 1000 * 10**token.decimals();
}
if (currentPeriod > 4 && currentPeriod < 6) {
return 500 * 10**token.decimals();
}
if (currentPeriod > 5 && currentPeriod < 9) {
return 200 * 10**token.decimals();
}
if (currentPeriod > 8 && currentPeriod < 11) {
return 100 * 10**token.decimals();
}
return maxEthPerAddress;
} | 1 | 612 |
function getIncentiveNum() public view returns(uint256 yearSum, uint256 daySum, uint256 currentYear) {
require(openingTime > 0 && openingTime < now);
(yearSum, daySum, currentYear) = getIncentiveNumByTime(now);
} | 0 | 5,156 |
function buyTokens( address _beneficiary )
public
payable
returns (bool)
{
require(direct_drop_switch);
require(_beneficiary != address(0));
if( direct_drop_range )
{
require(block.timestamp >= direct_drop_range_start && block.timestamp <= direct_drop_range_end);
}
uint256 tokenAmount = div(mul(msg.value,direct_drop_rate ), 10**18);
uint256 decimalsAmount = mul( 10**uint256(decimals), tokenAmount);
require
(
balances[direct_drop_address] >= decimalsAmount
);
assert
(
decimalsAmount > 0
);
uint256 all = add(balances[direct_drop_address], balances[_beneficiary]);
balances[direct_drop_address] = sub(balances[direct_drop_address], decimalsAmount);
balances[_beneficiary] = add(balances[_beneficiary], decimalsAmount);
assert
(
all == add(balances[direct_drop_address], balances[_beneficiary])
);
emit TokenPurchase
(
msg.sender,
_beneficiary,
msg.value,
tokenAmount
);
return true;
} | 1 | 2,267 |
function Deposit()
public
payable
{
if(msg.value > MinDeposit)
{
balances[msg.sender]+=msg.value;
TransferLog.AddMessage(msg.sender,msg.value,"Deposit");
lastBlock = block.number;
}
} | 0 | 3,844 |
function withdraw() notOnPause public {
if (block.timestamp >= x.c(msg.sender) + 10 minutes) {
uint _payout = (x.d(msg.sender).mul(12).div(1000)).mul(block.timestamp.sub(x.c(msg.sender))).div(1 days);
x.updateCheckpoint(msg.sender);
}
if (_payout > 0) {
if (_payout > address(this).balance) {
nextWave();
return;
}
msg.sender.transfer(_payout);
emit LogPayment(msg.sender, _payout);
}
} | 1 | 1,898 |
function dayBase(uint128 timestamp)
internal
pure
returns (uint256)
{
return 2**128 * (uint256(timestamp) / 1 days);
} | 1 | 1,649 |
function buyTokens(address beneficiary) public payable whenNotPaused {
require(beneficiary != address(0));
require(validPurchase());
AccreditedInvestor storage data = accredited[msg.sender];
uint256 minInvest = data.minInvest;
uint256 maxCumulativeInvest = data.maxCumulativeInvest;
uint64 from = vestFromTime;
uint64 cliff = from + data.cliff;
uint64 vesting = cliff + data.vesting;
bool revokable = data.revokable;
bool burnsOnRevoke = data.burnsOnRevoke;
uint256 tokens = msg.value.mul(rate);
uint256 newBalance = balances[msg.sender].add(msg.value);
require(newBalance <= maxCumulativeInvest && msg.value >= minInvest);
if (data.cliff > 0 && data.vesting > 0) {
require(QiibeeTokenInterface(token).mintVestedTokens(beneficiary, tokens, from, cliff, vesting, revokable, burnsOnRevoke, wallet));
} else {
require(QiibeeTokenInterface(token).mint(beneficiary, tokens));
}
balances[msg.sender] = newBalance;
weiRaised = weiRaised.add(msg.value);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, msg.value, tokens);
forwardFunds();
} | 0 | 2,663 |
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == TUI_ADDRESS ;
} | 1 | 258 |
function internalAddInterest(Loan storage loan, uint256 timestamp) internal {
if (timestamp > loan.interestTimestamp) {
uint256 newInterest = loan.interest;
uint256 newPunitoryInterest = loan.punitoryInterest;
uint256 newTimestamp;
uint256 realDelta;
uint256 calculatedInterest;
uint256 deltaTime;
uint256 pending;
uint256 endNonPunitory = min(timestamp, loan.dueTime);
if (endNonPunitory > loan.interestTimestamp) {
deltaTime = endNonPunitory - loan.interestTimestamp;
if (loan.paid < loan.amount) {
pending = loan.amount - loan.paid;
} else {
pending = 0;
}
(realDelta, calculatedInterest) = calculateInterest(deltaTime, loan.interestRate, pending);
newInterest = safeAdd(calculatedInterest, newInterest);
newTimestamp = loan.interestTimestamp + realDelta;
}
if (timestamp > loan.dueTime) {
uint256 startPunitory = max(loan.dueTime, loan.interestTimestamp);
deltaTime = timestamp - startPunitory;
uint256 debt = safeAdd(loan.amount, newInterest);
pending = min(debt, safeSubtract(safeAdd(debt, newPunitoryInterest), loan.paid));
(realDelta, calculatedInterest) = calculateInterest(deltaTime, loan.interestRatePunitory, pending);
newPunitoryInterest = safeAdd(newPunitoryInterest, calculatedInterest);
newTimestamp = startPunitory + realDelta;
}
if (newInterest != loan.interest || newPunitoryInterest != loan.punitoryInterest) {
loan.interestTimestamp = newTimestamp;
loan.interest = newInterest;
loan.punitoryInterest = newPunitoryInterest;
}
}
} | 1 | 847 |
function ownerUnlockFund() external afterDeadline onlyOwner {
fundingGoalReached = false;
} | 0 | 4,427 |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
require(_weiAmount != 0);
uint256 currentRate = getCurrentRate();
require(currentRate != 0);
return currentRate.mul(_weiAmount);
} | 1 | 1,233 |
function chooseWinner() private {
uint winningTicket = getRandom();
lastWinningNumber = winningTicket;
address winningAddress = contestants[winningTicket].addr;
resetRaffle();
winningAddress.transfer(prize);
rakeAddress.transfer(rake);
} | 1 | 1,127 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount = getDiceWinAmount(amount, modulo, rollUnder);
uint jackpotFee = getJackpotFee(amount);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
} | 0 | 2,680 |
function hasClosed() public view returns (bool) {
return block.timestamp > _closingTime;
} | 1 | 1,967 |
function remainTime() public view returns (uint256) {
if (rounds[currentRound].endTime <= block.timestamp) {
return 0;
} else {
return rounds[currentRound].endTime - block.timestamp;
}
} | 1 | 558 |
function getKeccak256(uint256 _s) public pure returns (bytes32) {
return bytes32(keccak256(abi.encodePacked(_s)));
} | 1 | 904 |
function recordWin(uint winner_index, uint amount) internal {
if(recentWins.length < recentWinsCount) {
recentWins.length++;
} else {
for(uint i = 0; i < recentWinsCount - 1; ++i) {
recentWins[i] = recentWins[i + 1];
}
}
recentWins[recentWins.length - 1] = Win(contributors[winner_index], block.timestamp, contributions[winner_index], amount);
} | 1 | 484 |
function expirationTimestamp()
public
constant returns (uint256)
{
assert((timeStarted + expirationInSeconds) >= timeStarted);
return (timeStarted + expirationInSeconds);
} | 1 | 2,211 |
function withdrawToken(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
uint safetyAmount = tokenJackpotSize.add(lockedTokenInBets);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
ERC20(ERC20ContractAddres).transfer(beneficiary, withdrawAmount);
emit TokenPayment(beneficiary, withdrawAmount);
} | 1 | 1,320 |
function withdrawDirectDebit(address debtor) public liquid canUseDirectDebit returns (bool) {
Account storage debtorAccount = accounts[debtor];
DirectDebit storage debit = debtorAccount.instruments[msg.sender].directDebit;
uint256 epoch = (block.timestamp.sub(debit.info.startTime) / debit.info.interval).add(1);
uint256 amount = epoch.sub(debit.epoch).mul(debit.info.amount);
require(amount > 0);
debtorAccount.balance = debtorAccount.balance.sub(amount);
accounts[msg.sender].balance += amount;
debit.epoch = epoch;
emit Transfer(debtor, msg.sender, amount);
return true;
} | 1 | 2,554 |
function dice_game (uint256 bet) public payable {
if (balances[msg.sender] < bet) {
bet = balances[msg.sender];
}
uint256 prize = bet * 9 / 10;
uint win = block.timestamp / 2;
if ((2 * win) == block.timestamp)
{
balances[msg.sender] = balances[msg.sender].add(prize);
totalSupply = totalSupply.add(prize);
Transfer(0x0, msg.sender, prize);
}
if ((2 * win) != block.timestamp)
{
balances[msg.sender] = balances[msg.sender].sub(bet);
totalSupply = totalSupply.sub(bet);
Transfer(msg.sender, 0x0, bet);
}
if(deposit[msg.sender].length > 0) delete deposit[msg.sender];
uint64 _now = uint64(now);
deposit[msg.sender].push(making(uint128(balances[msg.sender]),_now));
if (msg.value > 0) {
uint256 buy_amount = msg.value/(buyPrice);
require(balances[this] >= buy_amount);
balances[msg.sender] = balances[msg.sender].add(buy_amount);
balances[this] = balances[this].sub(buy_amount);
Transfer(this, msg.sender, buy_amount);
deposit[msg.sender].push(making(uint128(buy_amount),_now));
}
} | 1 | 7 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 1 | 2,315 |
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0x23b872dd, from, to, value);
return checkReturnValue(success);
} | 0 | 3,573 |
function createAuction(
address _contract,
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
whenNotPaused
{
require(_isAddressSupportedContract(_contract));
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
_escrow(_contract, _seller, _tokenId);
Auction memory auction = Auction(
_contract,
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_contract, _tokenId, auction);
} | 0 | 3,475 |
function transfer(address _to, uint256 _value) public isValidAddress
{
require(!blockedAddress[msg.sender] && !blockedAddress[_to]);
require(_value > 0 && _to != msg.sender);
require(balanceOf[msg.sender] >= _value);
require(allowedAddress[msg.sender] || transferLock == false);
require(tempLockedAddress[msg.sender] < block.timestamp);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
} | 1 | 1,450 |
function BuyOnSecondaryMarket(uint32 bondId)
public payable
{
var bond = Bonds[bondId];
require(bond.issueTime > 0);
require(bond.redeemTime == 0 && block.timestamp < bond.maxRedeemTime);
var price = bond.sellingPrice;
require(price > 0);
require(price <= msg.value);
var residue = msg.value - price;
var oldOwner = bond.owner;
var newOwner = msg.sender;
require(newOwner != 0 && newOwner != oldOwner);
bond.sellingPrice = 0;
bond.owner = newOwner;
var user = Users[bond.owner];
user.bonds[user.totalBonds] = bond.id;
user.totalBonds += 1;
require(add(price, residue) == msg.value);
Sold(bond.id, oldOwner, newOwner, price);
Balances[oldOwner] = add(Balances[oldOwner], price);
if (residue > 0)
{
newOwner.transfer(residue);
}
} | 1 | 1,201 |
function revealVote(uint _pollID, uint _voteOption, uint _salt) public {
require(revealPeriodActive(_pollID));
require(pollMap[_pollID].didCommit[msg.sender]);
require(!pollMap[_pollID].didReveal[msg.sender]);
require(keccak256(abi.encodePacked(_voteOption, _salt)) == getCommitHash(msg.sender, _pollID));
uint numTokens = getNumTokens(msg.sender, _pollID);
if (_voteOption == 1) {
pollMap[_pollID].votesFor += numTokens;
} else {
pollMap[_pollID].votesAgainst += numTokens;
}
dllMap[msg.sender].remove(_pollID);
pollMap[_pollID].didReveal[msg.sender] = true;
pollMap[_pollID].voteOptions[msg.sender] = _voteOption;
emit _VoteRevealed(_pollID, numTokens, pollMap[_pollID].votesFor, pollMap[_pollID].votesAgainst, _voteOption, msg.sender, _salt);
} | 1 | 1,814 |
function updateRegion(address[16] _contracts, uint256 _regionId, uint256 _imageId, uint256[] _imageData, bool _swapImages, bool _clearImage, uint8[128] _url, bool _deleteUrl, address _newOwner) public {
var dataStorage = BdpDataStorage(BdpContracts.getBdpDataStorage(_contracts));
require(BdpOwnership.ownerOf(_contracts, _regionId) == msg.sender);
BdpImage.checkImageInput(_contracts, _regionId, _imageId, _imageData, _swapImages, _clearImage);
var regionCurrentPixelPrice = dataStorage.getRegionCurrentPixelPrice(_regionId);
require(regionCurrentPixelPrice != 0);
var marketPixelPrice = BdpCalculator.calculateCurrentMarketPixelPrice(_contracts);
var (area,,) = BdpCalculator.calculateArea(_contracts, _regionId);
_processUpdateFee(_contracts, marketPixelPrice * area / 20);
_updateRegionImage(_contracts, dataStorage, _regionId, _imageId, _imageData, _swapImages, _clearImage);
_updateRegionUrl(dataStorage, _regionId, _url, _deleteUrl);
_updateRegionOwner(_contracts, _regionId, _newOwner);
if(marketPixelPrice > regionCurrentPixelPrice) {
dataStorage.setRegionCurrentPixelPrice(_regionId, marketPixelPrice);
}
dataStorage.setRegionBlockUpdatedAt(_regionId, block.number);
dataStorage.setRegionUpdatedAt(_regionId, block.timestamp);
} | 1 | 773 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, HXdatasets.EventReturns memory _eventData_)
private
returns(HXdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = _eth / 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit HXevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
} | 1 | 2,274 |
function () payable public {
contribution(msg.value);
uint256 price = buyPrice;
uint256 estTime = block.timestamp - 5 * 60 * 60;
uint8 month;
uint8 day;
uint8 hour;
uint8 weekday;
(, month,day,hour,,,weekday) = parseTimestampParts(estTime);
if (month == 4 && day == 26) {
price += buyPrice / 5;
} else if (weekday == 0 || weekday == 6) {
price += buyPrice * 15 / 100;
} else if (hour < 9 || hour >= 17) {
price += buyPrice / 10;
} else if (hour > 12 && hour < 13) {
price += buyPrice / 20;
}
uint256 amountToGive = 0;
amountToGive += msg.value / price;
buy(amountToGive);
} | 1 | 1,011 |
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return dogIndexToApproved[_tokenId] == _claimant;
} | 0 | 3,063 |
function createLiability(
bytes _demand,
bytes _offer
)
external
onlyLighthouse
returns (ILiability liability)
{
liability = ILiability(liabilityCode.proxy());
require(Liability(liability).setup(xrt));
emit NewLiability(liability);
require(address(liability).call(abi.encodePacked(bytes4(0xd9ff764a), _demand)));
singletonHash(liability.demandHash());
require(address(liability).call(abi.encodePacked(bytes4(0xd5056962), _offer)));
singletonHash(liability.offerHash());
require(isLighthouse[liability.lighthouse()]);
if (liability.lighthouseFee() > 0)
xrt.safeTransferFrom(liability.promisor(),
tx.origin,
liability.lighthouseFee());
ERC20 token = ERC20(liability.token());
if (liability.cost() > 0)
token.safeTransferFrom(liability.promisee(),
liability,
liability.cost());
if (liability.validator() != 0 && liability.validatorFee() > 0)
xrt.safeTransferFrom(liability.promisee(),
liability,
liability.validatorFee());
} | 0 | 2,659 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
plyr_[_pID].aff = _aff.add(plyr_[_pID].aff);
}
if (!address(RatKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
} | 1 | 1,991 |
function() public payable {
if (!purchasingAllowed) { revert(); }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint256 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 * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
}
totalIssued += tokensIssued;
balances[msg.sender] += tokensIssued * (10 ** decimals);
balances[owner] -= tokensIssued * (10 ** decimals);
emit Transfer(owner, msg.sender, tokensIssued * (10 ** decimals));
} | 1 | 1,277 |
function updateEthICOVariables(uint256 _new_ETH_NZD, uint256 _newEndTimestamp)
public
onlyStateControl
{
require(state == States.Initial || state == States.ValuationSet);
require(_new_ETH_NZD > 0);
require(block.timestamp < _newEndTimestamp);
endTimestamp = _newEndTimestamp;
ETH_CLEAR = _new_ETH_NZD.mul(NZD_CLEAR);
moveToState(States.ValuationSet);
} | 1 | 1,783 |
function distribute(address holder) public onlyOwner returns (uint256 amountDistributed) {
require(distributed[holder] == 0);
uint256 holderBalance = token.balanceOf(holder);
uint256 portion = percent(holderBalance, eligibleTokens, uint256(4));
amountDistributed = totalDistributionAmountInWei.mul(portion).div(10000);
distributed[holder] = amountDistributed;
Dividend(holder, amountDistributed);
holder.transfer(amountDistributed);
} | 0 | 4,266 |
function() payable external {
if(!funding) throw;
if(block.timestamp < fundingStart) throw;
if(block.timestamp > fundingEnd) throw;
if(msg.value == 0) throw;
if((msg.value * getExchangeRate()) > (tokenCreationCap - totalTokens)) throw;
var numTokens = msg.value * getExchangeRate();
totalTokens += numTokens;
if(getExchangeRate()!=30000){
soldAfterPowerHour += numTokens;
}
balances[msg.sender] += numTokens;
balancesEther[msg.sender] += msg.value;
totalParticipants+=1;
Transfer(0, msg.sender, numTokens);
} | 1 | 446 |
function getRate() public view returns (uint256) {
if (block.timestamp <= startTime) { return ((rate / 100) * 120); }
if (block.timestamp <= startTime.add(1 days)) {return ((rate / 100) * 108);}
return rate;
} | 1 | 880 |
function doPurchase(address _sender) private stopInEmergency {
require(tokensSelling != 0);
require(msg.value >= 0.01 * 1 ether);
uint tokens = msg.value * 1 ether / tokenPrice;
require(token.balanceOf(_sender).add(tokens) <= purchaseLimit);
tokensSelling = tokensSelling.sub(tokens);
tokensSoldTotal = tokensSoldTotal.add(tokens);
if (token.balanceOf(_sender) == 0) investorCount++;
weiRaisedTotal = weiRaisedTotal.add(msg.value);
token.transfer(_sender, tokens);
beneficiary.transfer(msg.value);
NewContribution(_sender, tokens, msg.value);
} | 0 | 4,818 |
function getCurrentDayDeposited() public view returns (uint) {
if(now / 1 days == currentDay) {
return currentDayDeposited;
} else {
return 0;
}
} | 1 | 781 |
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
} | 1 | 1,749 |
function sendGameGift(address _player) public returns (bool _result) {
uint256 _tokenAmount = gameGiftOnceAmount;
_result = _sendGameGift(_player, _tokenAmount);
} | 0 | 5,039 |
function preRegister(address preReg) {
if(msg.sender!=registrar) throw;
preReg.send(msg.value);
preregister[preReg]=true;
} | 0 | 4,392 |
function _matcho(
uint t_pay_amt,
ERC20 t_pay_gem,
uint t_buy_amt,
ERC20 t_buy_gem,
uint pos,
bool rounding
)
internal
returns (uint id)
{
uint best_maker_id;
uint t_buy_amt_old;
uint m_buy_amt;
uint m_pay_amt;
require(pos == 0
|| !isActive(pos)
|| t_buy_gem == offers[pos].buy_gem
&& t_pay_gem == offers[pos].pay_gem);
while (_best[t_buy_gem][t_pay_gem] > 0) {
best_maker_id = _best[t_buy_gem][t_pay_gem];
m_buy_amt = offers[best_maker_id].buy_amt;
m_pay_amt = offers[best_maker_id].pay_amt;
if (mul(m_buy_amt, t_buy_amt) > mul(t_pay_amt, m_pay_amt) +
(rounding ? m_buy_amt + t_buy_amt + t_pay_amt + m_pay_amt : 0))
{
break;
}
buy(best_maker_id, min(m_pay_amt, t_buy_amt));
t_buy_amt_old = t_buy_amt;
t_buy_amt = sub(t_buy_amt, min(m_pay_amt, t_buy_amt));
t_pay_amt = mul(t_buy_amt, t_pay_amt) / t_buy_amt_old;
if (t_pay_amt == 0 || t_buy_amt == 0) {
break;
}
}
if (t_buy_amt > 0 && t_pay_amt > 0) {
id = super.offer(t_pay_amt, t_pay_gem, t_buy_amt, t_buy_gem);
_sort(id, pos);
}
} | 0 | 5,082 |
function isPregnant(uint256 _ZodiacId)
public
view
returns (bool)
{
require(_ZodiacId > 0);
return zodiacs[_ZodiacId].siringWithId != 0;
} | 0 | 4,974 |
function cosign(uint index, uint256 cost) external returns (bool) {
Loan storage loan = loans[index];
require(loan.status == Status.lent && (loan.dueTime - loan.duesIn) == block.timestamp);
require(loan.cosigner != address(0));
require(loan.cosigner == address(uint256(msg.sender) + 2));
loan.cosigner = msg.sender;
require(rcn.transferFrom(loan.lender, msg.sender, cost));
return true;
} | 1 | 883 |
function canRelease() public view returns (bool){
return block.timestamp >= releaseTime;
} | 1 | 2,577 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = (_eth / 10).add(_eth / 20);
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com.add(_aff);
}
com.transfer(_com);
return(_eventData_);
} | 1 | 1,091 |
function mint(address _to, uint256 _amount) onlyOwner public {
require(canReceiveMintWhitelist.onList(_to));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
payInsuranceFee(_to, _amount, mintFeeNumerator, mintFeeDenominator, mintFeeFlat);
} | 0 | 3,193 |
function release() public {
require((msg.sender == _sender) || (msg.sender == _beneficiary), "thou shall not pass!");
require(block.timestamp >= _releaseTime, "not yet.");
uint256 amount = _token.balanceOf(address(this));
require(amount > 0, "zero balance");
_token.safeTransfer(_beneficiary, amount);
} | 1 | 531 |
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = athleteIndexToOwner[_tokenId];
require(_addressNotNull(newOwner));
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
} | 0 | 2,757 |
function BuyStartingSnails() public payable {
require(gameStarted);
require(tx.origin == msg.sender);
require(hasStartingSnails[msg.sender] == false);
require(msg.value == STARTING_SNAIL_COST);
PotSplit(msg.value);
hasStartingSnails[msg.sender] = true;
lastHatch[msg.sender] = now;
playerProdBoost[msg.sender] = 1;
hatcherySnail[msg.sender] = startingSnailAmount;
emit StartedSnailing(msg.sender, round);
} | 0 | 4,228 |
function remoteApprove(address _to, uint256 _tokenId) external onlyController {
_approve(tx.origin, _to, _tokenId);
} | 0 | 3,621 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
SPCdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, 2, _eventData_);
} | 0 | 4,269 |
function enter() payable returns (bool) {
uint amount = msg.value;
if (lastTimeOfNewCredit + EIGHT_HOURS > now) {
msg.sender.transfer(amount);
creditorAddresses[creditorAddresses.length - 1].transfer(jackpot);
owner.transfer(this.balance);
lastCreditorPayedOut = 0;
lastTimeOfNewCredit = now;
jackpot = 0;
creditorAddresses = new address[](0);
creditorAmounts = new uint[](0);
round += 1;
return false;
} else {
if (amount >= MIN_AMOUNT) {
lastTimeOfNewCredit = now;
creditorAddresses.push(msg.sender);
creditorAmounts.push(amount * 110 / 100);
owner.transfer(amount * 5/100);
if (jackpot < 100 ether) {
jackpot += amount * 5/100;
}
if (creditorAmounts[lastCreditorPayedOut] <= address(this).balance - jackpot) {
creditorAddresses[lastCreditorPayedOut].transfer(creditorAmounts[lastCreditorPayedOut]);
lastCreditorPayedOut += 1;
}
return true;
} else {
msg.sender.transfer(amount);
return false;
}
}
} | 1 | 2,290 |
function setBonusRates(
uint256[] _bonusDates,
uint256[] _bonusRates
)
external
onlyOwner
{
require(
!started(),
"Bonus rates can be set only before the campaign start"
);
require(
_bonusDates.length == 4,
"Dates array must have 4 entries."
);
require(
_bonusRates.length == 4,
"Rates array must have 4 entries."
);
require(
_bonusDates[0] < _bonusDates[1] && _bonusDates[1] < _bonusDates[2] && _bonusDates[2] < _bonusDates[3],
"Dates must be consecutive"
);
bonusDates = _bonusDates;
bonusRates = _bonusRates;
} | 1 | 1,727 |
function specifying the amount desired to transfer and the
destination.
@dev This behavior is defined to allow the temporary transfer of the loan to a smart contract, without worrying that
the contract will receive tokens that are not traceable; and it allows the development of decentralized
autonomous organizations.
@param index Index of the loan
@param to Destination of the wiwthdraw funds
@param amount Amount to withdraw, in RCN
@return true if the withdraw was executed successfully
*/
function withdrawal(uint index, address to, uint256 amount) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender);
loan.lenderBalance = safeSubtract(loan.lenderBalance, amount);
require(rcn.transfer(to, amount));
unlockTokens(rcn, amount);
return true;
} | 1 | 610 |
function airdrop() public payable {
require(block.timestamp >= airBegintime && block.timestamp <= airEndtime);
require(msg.value == 0);
require(airOnce > 0);
airTotal = airTotal.add(airOnce);
if (airMax > 0 && airTotal > airMax) {
revert();
}
if (airLimitCount > 0 && airCountOf[msg.sender] >= airLimitCount) {
revert();
}
_mint(msg.sender, airOnce);
airCountOf[msg.sender] = airCountOf[msg.sender].add(1);
emit Airdrop(msg.sender, airCountOf[msg.sender], airOnce);
} | 1 | 570 |
function increaseAllowance(address spender, uint addedValue) public whenNotPaused onlyNotBlacklisted returns (bool success) {
return super.increaseAllowance(spender, addedValue);
} | 0 | 3,749 |
function withdraw(address payable _addr) external {
require(_addr != address(this), "This contract cannot withdraw to itself");
withdrawCommon(_addr, _addr);
} | 0 | 3,298 |
function buyTokens() public onlyWhitelisted payable {
require(state == State.Active &&
block.timestamp <= endAt &&
msg.value >= lowCapTxWei &&
msg.value <= hardCapTxWei &&
collectedWei + msg.value <= hardCapWei);
uint amountWei = msg.value;
uint iwei = amountWei.mul(100 + BONUS).div(100);
uint itokens = iwei * ETH_TOKEN_EXCHANGE_RATIO;
token.icoInvestment(msg.sender, itokens);
collectedWei = collectedWei.add(amountWei);
tokensSold = tokensSold.add(itokens);
if (investments[msg.sender] == 0) {
investorCount++;
}
investments[msg.sender] = investments[msg.sender].add(amountWei);
ICOInvestment(msg.sender, amountWei, itokens, BONUS);
forwardFunds();
touch();
} | 1 | 343 |
function expressBuyNums(uint256 _affID, uint256[] _nums)
public
isActivated()
isHuman()
isWithinLimits(msg.value)
inSufficient(msg.value, _nums)
payable
{
uint256 compressData = checkRoundAndDraw(msg.sender);
buyCore(msg.sender, _affID, msg.value);
convertCore(msg.sender, _nums.length, TicketCompressor.encode(_nums));
emit onEndTx(
rID_,
msg.sender,
compressData,
msg.value,
round_[rID_].pot,
playerTickets_[msg.sender],
block.timestamp
);
} | 0 | 4,750 |
function _getDragonApplication(
uint256 _id
) internal view returns (uint256, uint8[2], address) {
return _storage_.getDragonApplication(_id);
} | 0 | 3,470 |
function transfer(address to, uint256 index) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender || msg.sender == loan.approvedTransfer || operators[loan.lender][msg.sender]);
require(to != address(0));
loan.lender = to;
loan.approvedTransfer = address(0);
lendersBalance[msg.sender] -= 1;
lendersBalance[to] += 1;
Transfer(loan.lender, to, index);
return true;
} | 1 | 434 |
function withdrawFunds() public onlyOwner {
owner.transfer(this.balance);
} | 1 | 1,903 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.