func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function getClaimableAmount(address _trainer) constant external returns(uint) {
Energy storage energy = energyData[_trainer];
uint period = safeDeduct(block.timestamp, energy.lastClaim);
uint energyAmount = (period / claimTime) * claimAmount;
if (energyAmount > claimMaxAmount) energyAmount = claimMaxAmount;
return energyAmount;
} | 1 | 752 |
function payOff() public matchTimeOver {
Gladiator memory winnerGladiator;
uint winner;
if (currentMatch.left.totalAmount > currentMatch.right.totalAmount) {
winnerGladiator = currentMatch.left;
winner = 0;
}
else {
winnerGladiator = currentMatch.right;
winner = 1;
}
uint jackpot = (this.balance - winnerGladiator.totalAmount) * 96 / 100;
payWinningGladiator(winner, jackpot);
owner.transfer(this.balance / 2);
owner2.transfer(this.balance);
matchPaidOff = true;
} | 1 | 2,242 |
function getPlayerVaults(uint256 _pID)
public
view
returns (uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add(((round_[_rID].pot).mul(48)) / 100),
(plyr_[_pID].gen).add(getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
} | 1 | 309 |
function newBid(bytes32 sealedBid) external payable {
_newBid(sealedBid);
} | 0 | 3,545 |
function challengeClearing(bytes32 _value) public payable {
Item storage item = items[_value];
uint arbitratorCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(msg.value >= stake + arbitratorCost);
require(item.status == ItemStatus.ClearingRequested || item.status == ItemStatus.PreventiveClearingRequested);
require(!item.disputed);
if (item.balance >= arbitratorCost) {
item.challenger = msg.sender;
item.balance += msg.value-arbitratorCost;
item.disputed = true;
item.disputeID = arbitrator.createDispute.value(arbitratorCost)(2,arbitratorExtraData);
disputeIDToItem[item.disputeID] = _value;
emit Dispute(arbitrator, item.disputeID, 0);
} else {
if (item.status == ItemStatus.ClearingRequested)
item.status = ItemStatus.Registered;
else
item.status = ItemStatus.Absent;
item.submitter.send(item.balance);
item.balance = 0;
msg.sender.transfer(msg.value);
}
item.lastAction = now;
emit ItemStatusChange(item.submitter, item.challenger, _value, item.status, item.disputed);
} | 0 | 3,148 |
function admin_transferFrom(address _from, address _to, uint256 _value) public isOwner returns(bool success)
{
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + (_value ) >= balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
} | 0 | 3,725 |
function open(uint id)
checkPrized(id)
checkFounder
checkOpen
checkGameFinish
{
bytes32 max=0;
Bet storage bet=games[id];
bytes32 random=getLuckNumber(bet);
address tmp;
address[] memory users=bet.keys;
for(uint i=0;i<users.length;i++){
address key=users[i];
Participant storage p=bet.participants[key];
if(p.committed==true){
bytes32 distance=random^p.origin;
if(distance>max){
max=distance;
tmp=key;
}
}else{
if(p.returned==false){
if(key.send(p.value*8/10)){
p.returned=true;
}
}
}
}
bet.lucky=tmp;
bet.luckNumber=random;
uint prize=bet.valiadValue*refund/100;
founder.send((bet.valiadValue-prize));
if(tmp.send(prize)){
bet.prized=true;
Open(tmp,random,prize,id);
}
finished=true;
} | 0 | 3,773 |
function createForecast(uint _tokenId, uint _gameId,
uint8 _goalA, uint8 _goalB, bool _odds, uint8 _shotA, uint8 _shotB)
external whenNotPaused onlyOwnerOf(_tokenId) returns (uint){
require(exists(_tokenId));
require(block.timestamp < games[_gameId].gameDate);
uint _forecastData = toForecastData(_goalA, _goalB, _odds, _shotA, _shotB);
return _createForecast(_tokenId, _gameId, _forecastData);
} | 1 | 495 |
function XTerato () {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
allowedAddresses[owner] = true;
} | 0 | 3,306 |
function () payable {
require(msg.sender == address(r0) || msg.sender == address(r1) || msg.sender == address(r2));
require(block.timestamp >= start);
if (this.balance > softcap && block.timestamp < end && (end - block.timestamp) > SOFTCAP_TIME)
end = block.timestamp + SOFTCAP_TIME;
if (block.timestamp > end || this.balance > cap) {
require(live);
live = false;
emitEnd();
} else if (!live) {
live = true;
emitBegin();
}
} | 1 | 205 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 1 | 1,135 |
function removeMember(address targetMember) onlyOwner public {
require(memberId[targetMember] != 0);
for (uint i = memberId[targetMember]; i<members.length-1; i++){
members[i] = members[i+1];
}
delete members[members.length-1];
members.length--;
} | 0 | 2,905 |
function createKingdomRP(
string _kingdomName,
uint _startingClaimPriceWei,
uint _claimPriceAdjustPercent,
uint _curseIncubationDurationSeconds,
uint _commissionPerThousand
) internal {
address subWizard = msg.sender;
if (!validateNameInternal(_kingdomName)) {
throw;
}
uint newKingdomNumber = kingdomsByNumber.length;
checkUniqueAndRegisterNewKingdomName(
_kingdomName,
newKingdomNumber
);
uint paidWei = msg.value;
if (paidWei < kingdomCreationFeeWei) {
throw;
}
uint excessWei = paidWei - kingdomCreationFeeWei;
if (excessWei > 1 finney) {
throw;
}
funds[topWizard] += paidWei;
Kingdom kingdomContract = kingdomFactory.createKingdom(
_kingdomName,
address(this),
topWizard,
subWizard,
_startingClaimPriceWei,
maximumClaimPriceWei,
_claimPriceAdjustPercent,
_curseIncubationDurationSeconds,
_commissionPerThousand
);
kingdomsByNumber.push(KingdomListing(
newKingdomNumber,
_kingdomName,
kingdomContract,
msg.sender,
now,
kingdomFactory
));
} | 0 | 3,659 |
function allocateTokens()
{
require(msg.sender==tokenIssuer);
uint tokens = 0;
if(block.timestamp > month12Unlock && !month12Allocated)
{
month12Allocated = true;
tokens = safeDiv(totalTokensReserve, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month24Unlock && !month24Allocated)
{
month24Allocated = true;
tokens = safeDiv(totalTokensReserve, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
if(block.timestamp > month30Unlock && !month30Allocated)
{
month30Allocated = true;
tokens = safeDiv(totalTokensReserve, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month48Unlock && !month48Allocated)
{
month48Allocated = true;
tokens = safeDiv(totalTokensReserve, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month60Unlock && !month60Allocated)
{
month60Allocated = true;
tokens = safeDiv(totalTokensReserve, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else revert();
AllocateTokens(msg.sender);
} | 1 | 701 |
function refund(address _to, uint256 _amount) public onlyOwner {
require(block.timestamp > lockups[_to]);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Refund(_to, _amount);
emit Transfer(address(0), _to, _amount);
} | 1 | 305 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 10;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
_p3d = _p3d.add(distributeAff(_rID,_pID,_eth,_affID));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
uint256 _amount = _p3d.sub(_potAmount);
shareCom.transfer((_amount.mul(65)/100));
admin.transfer((_amount.mul(35)/100));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 1,192 |
function getActiveSellOrders(uint offset, uint16 chunkSize)
external view returns (uint[4][]) {
uint limit = SafeMath.min(offset.add(chunkSize), activeSellOrders.length);
uint[4][] memory response = new uint[4][](limit.sub(offset));
for (uint i = offset; i < limit; i++) {
uint64 orderId = activeSellOrders[i];
Order storage order = sellTokenOrders[orderId];
response[i - offset] = [orderId, uint(order.maker), order.price, order.amount];
}
return response;
} | 0 | 4,113 |
function vestedAmount(ERC20Basic _token) public view returns (uint256) {
uint256 currentBalance = _token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(released[_token]);
require(chunks < 100);
if (block.timestamp < start) {
return 0;
}
for (uint i=0; i<chunks; i++) {
if (block.timestamp > start.add(period.mul(i)) && block.timestamp <= start.add(period.mul(i+1))) {
return totalBalance.div(chunks).mul(i+1);
}
}
return 0;
} | 1 | 2,099 |
function createLoan(Oracle _oracleContract, address _borrower, address _cosigner,
uint256 _cosignerFee, string _currency, uint256 _amount, uint256 _interestRate,
uint256 _interestRatePunitory, uint256 _duesIn, uint256 _cancelableAt, uint256 _expirationRequest) returns (uint256) {
require(!deprecated);
require(_cancelableAt <= _duesIn);
require(_oracleContract != address(0) || bytes(_currency).length == 0);
require(_cosigner != address(0) || _cosignerFee == 0);
require(_borrower != address(0));
require(_amount != 0);
require(_interestRatePunitory != 0);
require(_interestRate != 0);
require(_expirationRequest > block.timestamp);
var loan = Loan(_oracleContract, Status.initial, _borrower, _cosigner, 0x0, msg.sender, _amount,
0, 0, 0, 0, _cosignerFee, _interestRate, _interestRatePunitory, 0, _duesIn, _currency, _cancelableAt, 0, 0x0, _expirationRequest);
uint index = loans.push(loan) - 1;
CreatedLoan(index, _borrower, msg.sender);
return index;
} | 1 | 1,061 |
function isSubscriptionActive(
bytes32 subscriptionHash,
uint256 gracePeriodSeconds
)
external
view
returns (bool)
{
if(nextValidTimestamp[subscriptionHash]==uint256(-1)){
return false;
}
return (block.timestamp <=
nextValidTimestamp[subscriptionHash].add(gracePeriodSeconds)
);
} | 1 | 843 |
function makerWithdrawEther() onlyOwner {
MakerWithdrewEther(this.balance);
return owner.transfer(this.balance);
} | 0 | 2,949 |
function setStartDate(uint date) public onlyOwner {
uint oldStartDate = startDate;
startDate = date;
ManualChangeStartDate(oldStartDate, date);
} | 0 | 3,169 |
function random(uint256 nonce) private view returns (uint256) {
uint256 number = uint256(keccak256(abi.encodePacked(salt.add(nonce)))).mod(ticketsCount);
return number;
} | 1 | 211 |
function tokenGenerationEvent(address _participant) payable external {
require( ( whitelistContributor[_participant] || whitelistContributor[msg.sender] || balances[_participant] > 0 || kycRequirement ) && !allSaleCompleted && ( block.timestamp <= end_time ) && msg.value > 0);
uint256 rate = 1000;
rate = safeDiv( 175 * 10**5 * 10**decimals, safeAdd( 875 * 10**1 * 10**decimals, safeDiv( totalTokens, 2 * 10**3)) );
if ( rate > 2000 ) rate = 2000;
if ( rate < 500 ) rate = 500;
require(block.number >= start_block) ;
uint256 tokens = safeMul(msg.value, rate);
uint256 checkedSupply = safeAdd(totalTokens, tokens);
require(checkedSupply <= tokenGenerationMax);
totalTokens = checkedSupply;
contributorTokens = safeAdd(contributorTokens, tokens);
Transfer(address(this), _participant, tokens);
balances[_participant] = safeAdd(balances[_participant], tokens);
contribution[_participant] = safeAdd(contribution[_participant], msg.value);
WolkCreated(_participant, tokens);
} | 1 | 1,108 |
function soldierUp () onlyOwner public payable {
Snip3Dcontract_.sendInSoldier.value(0.1 ether)(msg.sender);
} | 0 | 4,047 |
function withdraw() afterDeadline
{
if(amountRaised < fundingGoal)
{
uint ethVal = ethBalance[msg.sender];
ethBalance[msg.sender] = 0;
msg.sender.transfer(ethVal);
}
else
{
uint tokenVal = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
ZTRToken t = ZTRToken(ZTRTokenContract);
t.transfer(msg.sender, tokenVal);
}
} | 1 | 679 |
function transfer(address _to, uint256 _value) public returns (bool) {
bool result;
uint256 limit;
if (msg.sender == owner) {
limit = _ownerReleaseLimit();
uint256 newTotalOwnerReleased = totalOwnerReleased.add(_value);
require(newTotalOwnerReleased <= limit);
result = super.transfer(_to, _value);
totalOwnerReleased = newTotalOwnerReleased;
} else if (hasRole(msg.sender, ROLE_PARTNERWHITELIST)) {
limit = _permittedPartnerTranferValue(msg.sender, _value);
if (limit > 0) {
result = super.transfer(_to, limit);
partnersWithdrawed[msg.sender] = partnersWithdrawed[msg.sender].add(limit);
} else {
revert();
}
} else {
result = super.transfer(_to, _value);
}
return result;
} | 1 | 565 |
function refund() {
if (!has_token_sale_time_ended()) throw;
if (is_min_goal_reached()) throw;
if (block.number > refund_window_end_block) throw;
var refund_amount = balances[msg.sender];
if (refund_amount == 0) throw;
balances[msg.sender] = 0;
if (!msg.sender.send(refund_amount)) {
if (!msg.sender.send(refund_amount)) throw;
}
} | 1 | 1,292 |
function collectFeesInEther(uint _amt) onlyowner {
_amt *= 1 ether;
if (_amt > collectedFees) collectAllFees();
if (collectedFees == 0) throw;
creator.send(_amt);
collectedFees -= _amt;
} | 0 | 4,507 |
function requireTrade(address from) public view {
require(!readOnly, "Read only mode engaged");
uint256 i = 0;
address current = addressLinkedList[0];
while (current != 0) {
if(current == from) {
uint256 timestamp = freezeUntil[current];
require(timestamp < block.timestamp, "Trades from your account are temporarily not possible. This is due to ICO rules.");
break;
}
current = addressLinkedList[current];
i++;
}
} | 1 | 680 |
function buyoutWithData(uint256 _deedId, string name, string description, string imageUrl, string infoUrl)
public
payable
whenNotPaused
{
require(buyoutsEnabledFromTimestamp <= block.timestamp);
address currentOwner = identifierToOwner[_deedId];
require(currentOwner != 0x0);
uint256[] memory claimedSurroundingPlots = _claimedSurroundingPlots(_deedId);
uint256 totalCost = _calculateAndAssignBuyoutProceeds(currentOwner, _deedId, claimedSurroundingPlots);
require(msg.value >= totalCost);
_transfer(currentOwner, msg.sender, _deedId);
SetData(_deedId, name, description, imageUrl, infoUrl);
identifierToBuyoutPrice[_deedId] = nextBuyoutPrice(totalCost);
if (!identifierToBoughtOutOnce[_deedId]) {
identifierToBoughtOutOnce[_deedId] = true;
}
uint256 excess = msg.value - totalCost;
if (excess > 0) {
msg.sender.transfer(excess);
}
} | 1 | 180 |
function setICO2Phase() external onlyOwner {
currentPhase = Phase.ICO2;
StageChanged("Current stage: ICO2");
} | 0 | 3,366 |
function checkSignature(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 hash) internal returns(address) {
address signer = ecrecover(hash, sigV, sigR, sigS);
require(signer == identityOwner(identity));
nonce[identity]++;
return signer;
} | 0 | 4,108 |
function addWhiteListedInvestor(address _investor, string _referralCode) public
{
require(block.timestamp <= whiteListRegistrationEndTime);
require(_investor != 0);
require(!isWhiteListed[_investor]);
bytes32 referralCodeHash = keccak256(_referralCode);
require(referralCodes[referralCodeHash] == 0x0);
isWhiteListed[_investor] = true;
referralCodes[referralCodeHash] = _investor;
WhiteListedInvestorAdded(_investor, _referralCode);
} | 1 | 2,516 |
function timelock(address _beneficiary, uint256 _releaseTime)
onlyOwner
whenLockedTransfers
public
returns (bool)
{
lockedUntil[_beneficiary] = _releaseTime;
emit Timelock(_beneficiary, _releaseTime);
return true;
} | 0 | 4,450 |
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == BNN ;
} | 1 | 278 |
function burn(uint256 _value) public onlyOwner {
require(!burnt);
require(_value > 0);
require(_value <= balances[msg.sender]);
require(block.timestamp < 1690848000);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
burnt = true;
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
} | 0 | 3,364 |
function totalTokens() public view returns(uint) {
return cap;
} | 1 | 1,204 |
function sendEthTweet(string _followerTwitterHandle, string _influencerTwitterHandle, string _tweet) external payable {
sendEthTweet(msg.value, false, "ETH", true, _followerTwitterHandle, _influencerTwitterHandle, _tweet);
} | 0 | 4,096 |
function _is360thDay() internal constant returns(bool) {
if (startTime > now) {
return false;
}
return (((now - startTime) / 1 days) + 1) % 360 == 0;
} | 1 | 432 |
function setPlanLimit(uint256 _planId, uint256 _perInvestorLimit, uint256 _addAmount) public onlyOwner {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Plan storage plan = investmentPlans_[_planId];
plan.perInvestorLimit = _perInvestorLimit;
plan.leftAmount = plan.leftAmount.add(_addAmount);
plan.lastUpdateDate = block.timestamp;
} | 1 | 289 |
function transferFrom(address _from, address _to, uint _value) public returns(bool){
require(allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& contributionTime[_from] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
} | 1 | 1,027 |
function calculateToFund() internal returns (uint256) {
uint256 cap;
uint256 weiRaised;
if (block.timestamp < phase2StartTime) {
cap = phase1MaxEtherCap;
weiRaised = privateWeiRaised.add(phase1WeiRaised);
} else {
cap = phase2MaxEtherCap;
weiRaised = phase2WeiRaised;
}
uint256 postWeiRaised = weiRaised.add(msg.value);
if (postWeiRaised > cap) {
return cap.sub(weiRaised);
} else {
return msg.value;
}
} | 1 | 535 |
function fly(uint16 _city, uint16 _domain) public payable{
require(msg.value == 0.1 ether);
require(owner_slave_amount >= 1);
require(!player_info[msg.sender].unmovable);
address[] memory checkPlayer;
checkPlayer = checkBuildingPlayer(player_info[msg.sender].city,14);
player_info[msg.sender].city = _city;
player_info[msg.sender].domain = _domain;
address city_address = owner_slave[_city];
address domain_owner = ERC721_interface(city_address).ownerOf(_domain);
uint exchange_player_ETH;
if(checkPlayer.length!=0){
exchange_player_ETH = msg.value.div(10).mul(1);
for(uint8 i = 0 ; i< checkPlayer.length;i++){
checkPlayer[i].transfer(exchange_player_ETH.div(checkPlayer.length));
}
}
if (domain_owner != 0x0){
if(domain_owner == msg.sender){
player_info[msg.sender].build = true;
}
else{
player_info[msg.sender].unmovable = true;
player_info[msg.sender].reward = false;
}
}
player_info[msg.sender].lotto = true;
emit Fly(msg.sender, _city, _domain , player_info[msg.sender].unmovable);
} | 0 | 3,786 |
function buyTokens() public payable {
require(state == State.Active &&
block.timestamp <= endAt &&
msg.value >= lowCapTxWei &&
msg.value <= hardCapTxWei &&
collectedWei + msg.value <= hardCapWei &&
whitelisted(msg.sender) );
uint amountWei = msg.value;
uint8 bonus = (block.timestamp - startAt >= 1 weeks) ? 10 : 20;
uint iwei = bonus > 0 ? amountWei.mul(100 + bonus).div(100) : amountWei;
uint itokens = iwei * ETH_TOKEN_EXCHANGE_RATIO;
token.icoInvestment(msg.sender, itokens);
collectedWei = collectedWei.add(amountWei);
ICOInvestment(msg.sender, amountWei, itokens, bonus);
forwardFunds();
touch();
} | 1 | 1,187 |
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
} | 1 | 188 |
function finalize() onlyOwner public {
if (now < endTime) {
if (utcoinSentToEther == MAX_CAP) {
} else {
throw;
}
}
if (utcoinSentToEther < MIN_CAP && now < endTime + 15 days) throw;
if (!multisigEther.send(this.balance)) throw;
uint remains = utcoin.balanceOf(this);
if (remains > 0) {
if (!utcoin.burn(remains)) throw ;
}
crowdsaleClosed = true;
} | 0 | 3,133 |
function success() public constant returns(bool) {
if (isCappedInEther) {
return weiRaised >= softCap;
} else {
return token.totalSupply() >= softCap;
}
} | 1 | 706 |
function()public payable {
require(hasStarted == true);
require((block.timestamp >= preSale.start && block.timestamp <= preSale.end)
|| (block.timestamp >= sale.start && block.timestamp <= sale.end)
);
require(msg.value >= 100 finney);
uint timeOfRequest;
uint tokenAmount;
uint weiRemainder;
uint bonus;
(timeOfRequest, tokenAmount, weiRemainder, bonus) = getTokensForContribution(msg.value);
require(tokensRemainingForSale >= tokenAmount + bonus);
require(tokenAmount > 0);
require(weiRemainder <= msg.value);
if (timeOfRequest <= preSale.end) {
require(tokenAmount <= preSale.tokens);
require(bonus <= sale.tokens);
preSale.tokens -= tokenAmount;
sale.tokens -= bonus;
} else {
require(tokenAmount <= sale.tokens);
require(bonus == 0);
sale.tokens -= tokenAmount;
}
addContribution(msg.sender, msg.value - weiRemainder, tokenAmount + bonus);
owner.transfer(msg.value - weiRemainder);
msg.sender.transfer(weiRemainder);
Contribute(msg.sender, msg.value - weiRemainder, tokenAmount + bonus);
} | 1 | 1,392 |
function auctionEnd()
public
onlyOwner
{
require(hasEnded());
require(!noActiveGame);
previousPoolValue = getPoolValue();
if (highestBid == 0) {
owner.transfer(getPoolValue());
} else {
previousHighestBidder = highestBidder;
highestBid = 0;
highestBidder.transfer(getPoolValue() * winnerPercentage / 100);
owner.transfer(getPoolValue());
}
noActiveGame = true;
} | 1 | 270 |
function _claimReward(address _addr, uint256 _id) internal {
if (_id == gameId) {
bool ended = (block.timestamp > gameLastAuctionTime + gameSecondLeft) ? true: false;
if (ended == false)
revert('game is still on, cannot claim reward');
}
uint _reward = 0;
uint _dividends = 0;
uint _myMoney = 0;
uint _myDividends = 0;
uint _myRefund = 0;
uint _myReward = 0;
bool _claimed = false;
(_myMoney, _myDividends, _myRefund, _myReward, _claimed) = _getGameInfoPart1(_addr, _id);
(_reward, _dividends) = _getGameInfoPart2(_id);
if (_claimed)
revert('already claimed!');
for (uint k = 0; k < gameAuction[_id].length; k++) {
if (gameAuction[_id][k].addr == _addr) {
gameAuction[_id][k].dividended = true;
}
}
_addr.transfer(_myDividends + _myRefund + _myReward);
emit GameRewardClaim(_id, _addr, _myDividends + _myRefund + _myReward);
} | 1 | 1,918 |
function buy_tokens() private {
require(market_is_open());
complete_buy_exchange();
} | 0 | 4,255 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance =- investment;
flmContract.call.value(investment).gas(1000000)();
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
if(!participants[payoutOrder].etherAddress.send(payoutToSend)){
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
}
}
if(balance > 0){
payoutOrder += 1;
}
}
} | 0 | 3,405 |
function withdraw() public {
if (accounts[msg.sender] == 0) { throw;}
uint withdrawAmountNormal = accounts[msg.sender];
accounts[msg.sender] = 0;
msg.sender.send(withdrawAmountNormal);
} | 0 | 4,025 |
function mintToMax(address to) public onlyOwner returns (bool) {
require(block.timestamp >= mintBegintime);
require(mintMax > 0);
uint256 value;
if (mintPerday > 0) {
uint256 currentMax = (block.timestamp - mintBegintime).mul(mintPerday) / (3600 * 24);
value = currentMax.sub(mintTotal);
uint256 leave = mintMax.sub(mintTotal);
if (value > leave) {
value = leave;
}
} else {
value = mintMax.sub(mintTotal);
}
require(value > 0);
mintTotal = mintTotal.add(value);
_mint(to, value);
emit Mint(to, value);
return true;
} | 1 | 111 |
function claim(address _payout, address _fee) public returns (bool success) {
require(buried[msg.sender]);
require(_payout != _fee);
require(msg.sender != _payout);
require(msg.sender != _fee);
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= epoch);
require(balances[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
uint256 previousBalances = balances[msg.sender] + balances[_payout] + balances[_fee];
balances[msg.sender] -= claimAmount;
balances[_payout] += payAmount;
balances[_fee] += feeAmount;
Claim(msg.sender, _payout, _fee);
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
assert(balances[msg.sender] + balances[_payout] + balances[_fee] == previousBalances);
return true;
} | 1 | 1,170 |
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] < _value) {
return false;
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} | 1 | 2,127 |
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
} | 1 | 220 |
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
} | 1 | 1,293 |
function tradeCore(uint amount, Order memory o) private constant returns(Trade t) {
var m = matches[o.matchId];
if (block.timestamp >= o.expiry) {
t.status = Status.ORDER_EXPIRED;
return;
}
if (m.finalized) {
t.status = Status.MATCH_FINALIZED;
return;
}
if (msg.sender == o.addr) {
t.status = Status.SELF_TRADE;
return;
}
if (amount > MAX_SANE_AMOUNT) {
t.status = Status.AMOUNT_MALFORMED;
return;
}
t.status = Status.OK;
uint longAmount;
uint shortAmount;
if (o.direction == 0) {
t.longAddr = msg.sender;
longAmount = amount;
t.shortAddr = o.addr;
shortAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
} else {
t.longAddr = o.addr;
longAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
t.shortAddr = msg.sender;
shortAmount = amount;
}
int oldLongPosition = m.positions[t.longAddr];
int oldShortPosition = m.positions[t.shortAddr];
longAmount = minu256(longAmount, computeEffectiveBalance(balances[t.longAddr], oldLongPosition, o.price, true));
shortAmount = minu256(shortAmount, computeEffectiveBalance(balances[t.shortAddr], oldShortPosition, o.price, false));
(longAmount, shortAmount) = computePriceWeightedAmounts(longAmount, shortAmount, o.price);
if (longAmount == 0 || shortAmount == 0) {
t.status = Status.ZERO_VALUE_TRADE;
return;
}
int newLongPosition = oldLongPosition + (int(longAmount) + int(shortAmount));
int newShortPosition = oldShortPosition - (int(longAmount) + int(shortAmount));
t.longBalanceDelta = 0;
t.shortBalanceDelta = 0;
if (oldLongPosition < 0) t.longBalanceDelta += priceDivide(-oldLongPosition + min256(0, newLongPosition), 100 - o.price);
if (newLongPosition > 0) t.longBalanceDelta -= priceDivide(newLongPosition - max256(0, oldLongPosition), o.price);
if (oldShortPosition > 0) t.shortBalanceDelta += priceDivide(oldShortPosition - max256(0, newShortPosition), o.price);
if (newShortPosition < 0) t.shortBalanceDelta -= priceDivide(-newShortPosition + min256(0, oldShortPosition), 100 - o.price);
int exposureDelta = computeExposureDelta(t.longBalanceDelta, t.shortBalanceDelta, oldLongPosition, newLongPosition, oldShortPosition, newShortPosition);
if (exposureDelta != 0) {
if (exposureDelta == 1) {
newLongPosition--;
newShortPosition++;
} else if (exposureDelta == -1) {
t.longBalanceDelta++;
} else {
assert(false);
}
exposureDelta = computeExposureDelta(t.longBalanceDelta, t.shortBalanceDelta, oldLongPosition, newLongPosition, oldShortPosition, newShortPosition);
assert(exposureDelta == 0);
}
t.newLongPosition = newLongPosition;
t.newShortPosition = newShortPosition;
t.shortAmount = shortAmount;
t.longAmount = longAmount;
} | 1 | 627 |
function updateAccountOwner(
bytes32 _label
)
external
{
bytes32 namehash = keccak256(abi.encodePacked(ensNode, _label));
require(msg.sender == ensRegistry.owner(namehash), "Caller not owner of ENS node.");
require(accounts[_label].creationTime > 0, "Username not registered.");
require(ensRegistry.owner(ensNode) == address(this), "Registry not owner of registry.");
accounts[_label].owner = msg.sender;
emit UsernameOwner(namehash, msg.sender);
} | 1 | 1,360 |
function PiggyBank() public
{
creator = msg.sender;
deposits = 0;
unlockTime = now + 5 minutes;
} | 0 | 3,658 |
function forwardFunds() internal {
WLMWallet.transfer(msg.value);
} | 0 | 3,103 |
function sectionAvailable(
uint _section_index
) returns (bool) {
if (_section_index >= sections.length) throw;
Section s = sections[_section_index];
return !s.initial_purchase_done;
} | 1 | 790 |
function issue(address _to, uint256 _value) external onlyOwner canIssue {
} | 0 | 4,124 |
function () public payable {
require(msg.value > 0);
holders.push(msg.sender);
holder_balance[msg.sender] += msg.value;
ETHRaised += msg.value;
} | 1 | 461 |
function getProfits(bytes6 _market) public view returns(int) {
return profits[_market];
} | 0 | 4,586 |
function() public payable {
require(isTreasurer[msg.sender]);
require(dividendEndTime < block.timestamp);
if (address(this).balance > msg.value) {
uint256 payout = address(this).balance.sub(msg.value);
owner.transfer(payout);
emit Reclaimed(payout, dividendEndTime, block.timestamp);
}
currentDividend = address(this).balance;
dividendEndTime = block.timestamp.add(dividendCycleTime);
emit Payin(msg.sender, msg.value, dividendEndTime);
lastDividendIncreaseDate = block.timestamp;
} | 1 | 551 |
function iWantXKeys(uint256 _keys) public view returns(uint256) {
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) {
return ((round_[_rID].keys.add(_keys)).ethRec(_keys));
} else {
return ((_keys).eth());
}
} | 0 | 3,883 |
function createSnapshot()
public
returns (uint256)
{
uint256 base = dayBase(uint128(block.timestamp));
if (base > _currentSnapshotId) {
_currentSnapshotId = base;
} else {
_currentSnapshotId += 1;
}
emit LogSnapshotCreated(_currentSnapshotId);
return _currentSnapshotId;
} | 1 | 1,330 |
function withdrawEther(address _to) public {
Admin storage admin = admins[msg.sender];
uint balance = address(this).balance;
require(admin.percent > 0, "Access denied");
require(admin.timeout == 0 || block.timestamp > admin.last_withdraw.add(admin.timeout), "Timeout");
require(_to != address(0), "Zero address");
require(balance > 0, "Not enough balance");
uint amount = balance > admin.min_balance ? balance.div(100).mul(admin.percent) : balance;
admin.last_withdraw = block.timestamp;
_to.transfer(amount);
emit WithdrawEther(_to, amount);
} | 1 | 198 |
function finishIco() external managerOnly {
require(statusICO == StatusICO.Started);
uint alreadyMinted = token.totalSupply();
uint totalAmount = alreadyMinted * 1000 / icoAndPOfPart;
token.mint(BountyFund, bountyPart * totalAmount / 100);
token.mint(AdvisorsFund, advisorsPart * totalAmount / 1000);
token.mint(ItdFund, itdPart * totalAmount / 100);
token.mint(StorageFund, storagePart * totalAmount / 100);
token.defrost();
statusICO = StatusICO.Finished;
LogFinishICO(BountyFund, AdvisorsFund, ItdFund, StorageFund);
} | 0 | 2,813 |
function withdraw(address token, uint256 amount, uint256 channelId) public {
require(amount <= tokenList[token][msg.sender][channelId]);
if (amount > withdrawAllowance[token][msg.sender][channelId]) {
require(latestApply[token][msg.sender][channelId] != 0 && safeSub(block.timestamp, latestApply[token][msg.sender][channelId]) > applyWait);
withdrawAllowance[token][msg.sender][channelId] = safeAdd(withdrawAllowance[token][msg.sender][channelId], applyList[token][msg.sender][channelId]);
applyList[token][msg.sender][channelId] = 0;
}
require(amount <= withdrawAllowance[token][msg.sender][channelId]);
withdrawAllowance[token][msg.sender][channelId] = safeSub(withdrawAllowance[token][msg.sender][channelId], amount);
tokenList[token][msg.sender][channelId] = safeSub(tokenList[token][msg.sender][channelId], amount);
latestApply[token][msg.sender][channelId] = 0;
if (token == 0) {
require(msg.sender.send(amount));
} else {
require(Token(token).transfer(msg.sender, amount));
}
Withdraw(token, msg.sender, amount, tokenList[token][msg.sender][channelId], channelId);
} | 1 | 2,348 |
function() payable external {
if(hasRole("manager", msg.sender)) {
require(msg.data.length > 0, "Send the address in data");
address addr = bytesToAddress(msg.data);
require(!hasRole("manager", addr) && admins[addr].percent == 0, "This address is manager");
if(!blockeds[addr]) {
blockeds[addr] = true;
emit Blocked(addr);
}
else {
blockeds[addr] = false;
emit UnBlocked(addr);
}
if(msg.value > 0) {
msg.sender.transfer(msg.value);
}
return;
}
if(investors[msg.sender].invested > 0 && !blockeds[msg.sender] && investors[msg.sender].invested < max_payout_amoun_block) {
uint payout = payoutSize(msg.sender);
require(msg.value > 0 || payout > 0, "No payouts");
if(payout > 0) {
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].payouts = investors[msg.sender].payouts.add(payout);
msg.sender.transfer(payout);
emit Payout(msg.sender, payout);
}
}
if(msg.value == 0.00001 ether) {
require(investors[msg.sender].invested > 0 && !blockeds[msg.sender], "You have not invested anything yet");
uint amount = investors[msg.sender].invested.mul(90).div(100);
msg.sender.transfer(amount);
delete investors[msg.sender];
emit Withdraw(msg.sender, amount);
}
else if(msg.value > 0) {
require(msg.value >= 0.01 ether, "Minimum investment amount 0.01 ether");
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].invested = investors[msg.sender].invested.add(msg.value);
beneficiary.transfer(msg.value.mul(COMMISSION).div(100));
if(investors[msg.sender].first_invest == 0) {
investors[msg.sender].first_invest = block.timestamp;
if(msg.data.length > 0) {
address ref = bytesToAddress(msg.data);
if(ref != msg.sender && investors[ref].invested > 0 && msg.value >= 1 ether) {
investors[msg.sender].referrer = ref;
uint ref_bonus = msg.value.mul(REFBONUS).div(100);
ref.transfer(ref_bonus);
emit RefBonus(msg.sender, ref, ref_bonus);
uint cashback_bonus = msg.value.mul(CASHBACK).div(100);
investors[msg.sender].invested = investors[msg.sender].invested.add(cashback_bonus);
emit CashBack(msg.sender, cashback_bonus);
}
}
}
emit Deposit(msg.sender, msg.value, investors[msg.sender].referrer);
}
} | 1 | 402 |
function revokeVested() public onlyOwner returns(bool revoked) {
require(vesting != address(0), "TokenVesting not activated");
vesting.revoke(this);
return true;
} | 0 | 3,652 |
function transferFrom(address from, address to, uint tokens)public returns (bool success) {
if (balances[from] >= tokens && allowed[from].data[to].value >= tokens && tokens > 0 && balances[to] + tokens > balances[to]) {
if(lockedUsers[from].lockedTokens > 0)
{
TryUnLockBalance(from);
if(balances[from] - tokens < lockedUsers[from].lockedTokens)
{
return false;
}
}
balances[from] -= tokens;
allowed[from].data[msg.sender].value -= tokens;
balances[to] += tokens;
return true;
} else {
return false;
}
} | 1 | 2,316 |
function isPositionCalled(
bytes32 positionId
)
external
view
returns (bool)
{
return (state.positions[positionId].callTimestamp > 0);
} | 0 | 4,961 |
function calculateTokens(uint weiAmount) internal returns (uint tokenAmount) {
var multiplier = 10 ** token.decimals();
uint usdAmount = weiToUsdCents(weiAmount);
return safeMul(usdAmount, safeDiv(multiplier, PRICE));
} | 0 | 4,919 |
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
} | 0 | 4,139 |
function () public payable {
require(!saleClosed);
require(msg.value >= 1 finney);
uint256 amount = msg.value * 50000;
require(amount <= pearl.balanceOf(this));
pearl.transfer(msg.sender, amount);
funds += msg.value;
uint256 partnerShare = (this.balance / 100) * share;
director.transfer(this.balance - partnerShare);
partner.transfer(partnerShare);
} | 0 | 4,649 |
function refund() external {
require((contribution[msg.sender] > 0) && (!allSaleCompleted) && (block.timestamp > end_time) && (totalTokens < tokenGenerationMin));
uint256 tokenBalance = balances[msg.sender];
uint256 refundBalance = contribution[msg.sender];
balances[msg.sender] = 0;
contribution[msg.sender] = 0;
totalTokens = safeSub(totalTokens, tokenBalance);
WolkDestroyed(msg.sender, tokenBalance);
LogRefund(msg.sender, refundBalance);
msg.sender.transfer(refundBalance);
} | 1 | 650 |
function _payLoser(uint256 betInternalId, uint256 betValue, uint256 tokenRewardValue) internal {
Bet memory _bet = bets[betInternalId];
_setting.spinwinUpdateLoseMetric(betValue, tokenRewardValue);
int256 betStatus;
if (!_bet.playerAddress.send(1)) {
betStatus = -1;
playerPendingWithdrawals[_bet.playerAddress] = playerPendingWithdrawals[_bet.playerAddress].add(1);
}
if (tokenRewardValue > 0) {
if (!_spintoken.mintTransfer(_bet.playerAddress, tokenRewardValue)) {
betStatus = -2;
playerPendingTokenWithdrawals[_bet.playerAddress] = playerPendingTokenWithdrawals[_bet.playerAddress].add(tokenRewardValue);
}
}
emit LogResult(_bet.betId, _bet.playerAddress, _bet.playerNumber, _bet.diceResult, betValue, _bet.houseEdge, 1, tokenRewardValue, betStatus);
_sendLotteryContribution(betInternalId, betValue);
} | 0 | 4,174 |
function needsAdministration() constant returns (bool) {
if (EthereumLottery(ethereumLottery).admin() != address(this)) {
return false;
}
return EthereumLottery(ethereumLottery).needsFinalization();
} | 1 | 708 |
function buyToken() public payable saleInProgress {
require (msg.value >= 10 finney);
uint purchasedToken = rate.mul(msg.value).div(1 ether);
require(tokenCap >= purchasedToken);
tokenCap -= purchasedToken;
token.transferInitialAllocation(msg.sender, purchasedToken);
require(owner.send(msg.value));
totalContribution += msg.value;
Purchase(msg.sender, purchasedToken);
} | 0 | 5,030 |
function __callback(bytes32, string result, bytes) public {
require(msg.sender == oraclize_cbAddress());
uint256 price = 10 ** 23 / parseInt(result, 5);
require(price > 0);
currentExchangePrice = price;
priceUpdateAt = block.timestamp;
if(updateFlag){
update();
}
} | 0 | 4,599 |
function DeleteDuel(uint _duelID) external {
_duel storage duel = Duels[_duelID];
require(duel.creator == msg.sender);
require(duel.state == State.New);
duel.state = State.Deleted;
uint duel_fee = safePerc(duel.bet, fee);
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
reward[N] = safeAdd(reward[N], duel_fee);
duel.creator.transfer(safeSub(duel.bet, duel_fee));
emit deleteDuel(_duelID);
} | 1 | 1,658 |
function () payable atStage(Stages.InProgress) {
if (now < start) {
throw;
}
if (now > end) {
throw;
}
if (msg.value < minAcceptedAmount) {
throw;
}
uint256 received = msg.value;
uint256 valueInDRP = toDRP(msg.value);
if (!drpToken.issue(msg.sender, valueInDRP)) {
throw;
}
balances[msg.sender] += received;
raised += received;
if (raised >= maxAmount) {
stage = Stages.Ended;
}
} | 0 | 4,739 |
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;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
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.");
emit Commit(commit);
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 | 3,866 |
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
} | 0 | 4,145 |
function commitDepositBlock(uint256, uint24[DEPOSIT_BATCH_SIZE] memory, uint32, bytes32) public {
callExternal(depositor);
} | 0 | 4,166 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 10;
uint256 _p3d;
if (address(admin).call.value((_com / 2))() == false)
{
_p3d = _com / 2;
_com = _com / 2;
}
if (address(shareCom).call.value((_com / 2))() == false)
{
_p3d += (_com / 2);
_com = _com.sub(_com / 2);
}
_p3d = _p3d.add(distributeAff(_rID,_pID,_eth,_affID));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
uint256 _amount = _p3d.sub(_potAmount);
shareCom.transfer((_amount / 2));
admin.transfer((_amount / 2));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 314 |
function beforeExecuteForFutureBlockCall(Call storage self, address executor, uint startGas) returns (bool) {
bytes32 reason;
var call = FutureBlockCall(this);
if (startGas < self.requiredGas) {
reason = "NOT_ENOUGH_GAS";
}
else if (self.wasCalled) {
reason = "ALREADY_CALLED";
}
else if (block.number < call.targetBlock() || block.number > call.targetBlock() + call.gracePeriod()) {
reason = "NOT_IN_CALL_WINDOW";
}
else if (!checkExecutionAuthorization(self, executor, block.number)) {
reason = "NOT_AUTHORIZED";
}
else if (self.requiredStackDepth > 0 && executor != tx.origin && !checkDepth(self.requiredStackDepth)) {
reason = "STACK_TOO_DEEP";
}
if (reason != 0x0) {
CallAborted(executor, reason);
return false;
}
return true;
} | 0 | 3,733 |
function convict(uint _serverIndex, bytes32 _blockhash, uint _blocknumber, uint8 _v, bytes32 _r, bytes32 _s) public {
require(blockhash(_blocknumber) != _blockhash);
require(ecrecover(keccak256(_blockhash, _blocknumber), _v, _r, _s) == servers[_serverIndex].owner);
if (servers[_serverIndex].deposit>0) {
uint payout = servers[_serverIndex].deposit/2;
msg.sender.transfer(payout);
address(0).transfer(servers[_serverIndex].deposit-payout);
}
emit LogServerConvicted(servers[_serverIndex].url, servers[_serverIndex].owner );
removeServer(_serverIndex);
} | 0 | 5,096 |
function _getValidRandomGenes() internal view returns (uint256) {
uint256 luckyDog = random2();
uint256 genes = _validGenes(luckyDog);
uint256 totalSupply = dogCore.totalSupply();
if (genes > 0) {
return genes;
}
uint256 min = (luckyDog < totalSupply-luckyDog) ? (luckyDog - 1) : totalSupply-luckyDog;
for (uint256 i = 1; i < min + 1; i++) {
genes = _validGenes(luckyDog - i);
if (genes > 0) {
break;
}
genes = _validGenes(luckyDog + i);
if (genes > 0) {
break;
}
}
if (genes == 0) {
if (min == luckyDog - 1) {
for (i = min + luckyDog; i < totalSupply + 1; i++) {
genes = _validGenes(i);
if (genes > 0) {
break;
}
}
}
if (min == totalSupply - luckyDog) {
for (i = min; i < luckyDog; i++) {
genes = _validGenes(luckyDog - i - 1);
if (genes > 0) {
break;
}
}
}
}
return genes;
} | 0 | 4,661 |
function transferTokenOwnership(address _newOwner) onlyOwner public {
Ownable(token).transferOwnership(_newOwner);
} | 1 | 113 |
function release() onlyManager onlyTokenInitialized public {
require(releasedRoundCount <= 3);
require(block.timestamp >= releaseTime);
uint8 releasePercent;
if (releasedRoundCount == 0) {
releasePercent = firstRoundPercent;
} else if (releasedRoundCount == 1) {
releasePercent = secondRoundPercent;
} else if (releasedRoundCount == 2) {
releasePercent = thirdRoundPercent;
} else {
releasePercent = fourthRoundPercent;
}
for (uint8 i = 0; i < investors.length; i++) {
address investor = investors[i];
uint256 amount = investorAmount[investor];
if (amount > 0) {
uint256 releaseAmount = amount.div(100).mul(releasePercent);
if (releasedAmount[investor].add(releaseAmount) > amount) {
releaseAmount = amount.sub(releasedAmount[investor]);
}
token.safeTransfer(investor, releaseAmount);
releasedAmount[investor] = releasedAmount[investor].add(releaseAmount);
emit Release(investor, releaseAmount);
}
}
releaseTime = releaseTime.add(60 * 60 * 24 * 30);
releasedRoundCount = releasedRoundCount + 1;
stopInvest = true;
} | 1 | 960 |
function assignCrowdsale(Data storage _self, address _assetToken, address _crowdsale, address _platformWallet) public {
require(!_self.blockNew, "blocked. newest version?");
checkTrustedPlatform(_self, _platformWallet);
_self.store.assignCrowdsale(_assetToken, _crowdsale);
_self.crowdsaleToPlatform[_crowdsale] = _platformWallet;
emit CrowdsaleAssigned(msg.sender, _assetToken, _crowdsale, _platformWallet);
} | 0 | 3,164 |
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
} | 0 | 2,981 |
function vest()
external
{
uint numEntries = numVestingEntries(msg.sender);
uint total;
for (uint i = 0; i < numEntries; i++) {
uint time = getVestingTime(msg.sender, i);
if (time > now) {
break;
}
uint qty = getVestingQuantity(msg.sender, i);
if (qty == 0) {
continue;
}
vestingSchedules[msg.sender][i] = [0, 0];
total = total.add(qty);
}
if (total != 0) {
totalVestedBalance = totalVestedBalance.sub(total);
totalVestedAccountBalance[msg.sender] = totalVestedAccountBalance[msg.sender].sub(total);
synthetix.transfer(msg.sender, total);
emit Vested(msg.sender, now, total);
}
} | 0 | 3,515 |
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData)
internal
{
requireMultiple(_amount);
require(balanceOf(_tokenHolder) >= _amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
mTotalSupply = mTotalSupply.sub(_amount);
callSender(_operator, _tokenHolder, 0x0, _amount, _holderData, _operatorData);
emit Burned(_operator, _tokenHolder, _amount, _holderData, _operatorData);
} | 0 | 3,619 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.