func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function withdrawPrize() private {
require(lastDepositInfoForPrize.time > 0 && lastDepositInfoForPrize.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfoForPrize.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
uint prize = balance;
if(previosDepositInfoForPrize.index > 0){
uint prizePrevios = prize*10/100;
queue[previosDepositInfoForPrize.index].depositor.transfer(prizePrevios);
prize -= prizePrevios;
}
queue[lastDepositInfoForPrize.index].depositor.send(prize);
proceedToNewStage(getCurrentStageByTime() + 1);
} | 1 | 667 |
function endRound(POOHMODatasets.EventReturns memory _eventData_)
private
returns (POOHMODatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _dev = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _POOH = (_pot.mul(potSplit_[_winTID].pooh)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_dev)).sub(_gen)).sub(_POOH);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_dev);
flushDivs.call.value(_POOH)(bytes4(keccak256("donate()")));
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.POOHAmount = _POOH;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
rndMax_ = timerLengths[determineNextRoundLength()];
round_[_rID].end = now.add(rndMax_);
round_[_rID].pot = _res;
return(_eventData_);
} | 1 | 357 |
function invest() {
investors.push(Investor({
addr: msg.sender,
value: msg.value,
leftPayDays: calculateROI(),
lastDay: getDay()
}));
balance += msg.value * 99 / 100;
currentManager.send(msg.value / 100);
Invest(msg.sender, msg.value);
} | 1 | 967 |
function withdraw(uint amount) onlyOwner {
ownerAddress.send(amount);
} | 1 | 1,353 |
function doSend(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking
)
internal
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData, _operatorData);
require(_to != address(0));
require(mBalances[_from] >= _amount);
mBalances[_from] = mBalances[_from].sub(_amount);
mBalances[_to] = mBalances[_to].add(_amount);
callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
} | 1 | 1,035 |
function finalizePRETDE()
onlyCofounders
NoPRETDEContributorsAwaitingTokens
{
require(dnnToken.PRETDESupplyRemaining() > 0);
dnnToken.sendUnsoldPRETDETokensToTDE();
} | 1 | 470 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 50 ether) {
msg.sender.send(msg.value - 50 ether);
amount = 50 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 300) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 300;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 1,396 |
function getTuber(uint256 _tokenId) public view returns (
string tuberName,
uint256 sellingPrice,
address owner
) {
Tuber storage tuber = tubers[_tokenId];
tuberName = tuber.name;
sellingPrice = tuberIndexToPrice[_tokenId];
owner = tuberIndexToOwner[_tokenId];
} | 0 | 2,527 |
function purchaseCity(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
City storage city = cityData[_tokenId];
uint256 price = city.price;
address oldOwner = city.owner;
address newOwner = msg.sender;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 excess = msg.value.sub(price);
uint256 profit = price.sub(city.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(3).div(100);
devOwed = devOwed.add(devCut);
transferCity(oldOwner, newOwner, _tokenId);
city.lastPrice = price;
city.price = getNextPrice(price);
CityPurchased(_tokenId, newOwner, price);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
uint256 countryId = _tokenId % COUNTRY_IDX;
address countryOwner;
(countryOwner,,,,) = countryContract.getCountryData(countryId);
require (countryOwner != address(0));
countryOwner.transfer(poolCut.mul(COUNTRY_PAYOUT).div(100));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
} | 0 | 1,549 |
function callSecondTarget () public payable onlyPlayers {
require (msg.value >= 0.005 ether);
secondTarget.call.value(msg.value)();
} | 1 | 1,256 |
function rbuyTokens(address recipient_addr, uint256 _numberOfTokens) public payable {
require(msg.sender==admin);
require(msg.value == multiply(_numberOfTokens, tokenPrice));
require(tokenContract.balanceOf(address(this)) >= _numberOfTokens);
require(tokenContract.transfer(recipient_addr, _numberOfTokens));
tokensSold += _numberOfTokens;
emit Sell(msg.sender, _numberOfTokens);
} | 0 | 2,094 |
function mCurrentSnapshotId()
internal
constant
returns (uint256)
{
return dayBase(uint128(block.timestamp));
} | 0 | 1,555 |
function setTokenCurator(address _curatorAddress){
if( msg.sender != dev) throw;
curator = _curatorAddress;
} | 0 | 2,496 |
function transfer(address from,address caddress,address[] _tos,uint[] v)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],v[i]);
}
return true;
} | 1 | 1,250 |
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
bytes32 digest = keccak256(challengeNumber, msg.sender, nonce );
if (digest != challenge_digest) revert();
if(uint256(digest) > miningTarget) revert();
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if(solution != 0x0) revert();
uint reward_amount = getMiningReward(digest);
balances[msg.sender] = balances[msg.sender].add(reward_amount);
_totalSupply = _totalSupply.add(reward_amount);
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
emit Mint(msg.sender, reward_amount, epochCount, challengeNumber );
return true;
} | 0 | 1,699 |
function sendTokensToBatch(uint256[] amounts, address[] recipients) public onlyOwner {
require(amounts.length == recipients.length);
for (uint i = 0; i < recipients.length; i++) {
sendTokensTo(amounts[i], recipients[i]);
}
} | 1 | 1,252 |
function senderAllowedFor(address buyer) internal view returns(bool) {
require(buyer != address(0));
return true;
} | 0 | 2,685 |
function withdrawByGid(uint256 _gId)
isActivated()
senderVerify()
playerVerify()
public
{
address _player = msg.sender;
uint256 _amount;
uint256 _withdrawSid;
uint256 _reachAmount;
bool _finish;
(_amount, _withdrawSid, _reachAmount, _finish) = getEarningsAmountByGoodsIndex(_gId);
if(_finish == true){
for(uint256 i = 0; i < playerGoodsList[_player].length; i++){
if(playerGoodsList[_player][i] == _gId)
break;
}
require(i < playerGoodsList[_player].length, "gid is wrong");
playerWithdrawList[_player].push(_gId);
playerGoodsList[_player][i] = playerGoodsList[_player][playerGoodsList[_player].length - 1];
playerGoodsList[_player].length--;
}else{
goodsList[_gId].withdrawSid = _withdrawSid;
goodsList[_gId].reachAmount = _reachAmount;
}
_player.transfer(_amount);
} | 1 | 79 |
function processPayment(uint moneyValue, bytes refData) private
{
if (msg.sender == laxmi)
{
totalSelfInvest = totalSelfInvest.add(moneyValue);
emit LogSelfInvestment(moneyValue);
return;
}
if (moneyValue == 0)
{
preparePayment();
return;
}
if (moneyValue < minimalDeposit)
{
totalPenalty = totalPenalty.add(moneyValue);
emit LogMinimalDepositPayment(msg.sender, moneyValue, totalPenalty);
return;
}
checkLimits(moneyValue);
address referrer = bytesToAddress(refData);
if (user[msg.sender].balance > 0 ||
refData.length != 20 ||
(!isUnlimitedContractInvest && moneyValue > getCurrentMaximalDeposit()) ||
referrer != laxmi &&
(
user[referrer].balance <= 0 ||
referrer == msg.sender)
)
{
uint amount = moneyValue.mul(procReturn).div(procKoef);
totalPenalty = totalPenalty.add(moneyValue.sub(amount));
emit LogPenaltyPayment(msg.sender, user[msg.sender].balance, refData.length, referrer, user[referrer].balance, moneyValue, amount, totalPenalty);
msg.sender.transfer(amount);
return;
}
uint nDay = getCurrentDay();
uint restDepositPerDay = getDayRestDepositLimit(nDay);
uint addDeposit = moneyValue;
if (!isUnlimitedDayInvest && moneyValue > restDepositPerDay)
{
uint returnDeposit = moneyValue.sub(restDepositPerDay);
uint returnAmount = returnDeposit.mul(procReturn).div(procKoef);
addDeposit = addDeposit.sub(returnDeposit);
totalPenalty = totalPenalty.add(returnDeposit.sub(returnAmount));
emit LogExceededRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, returnDeposit, returnAmount, totalPenalty, addDeposit);
msg.sender.transfer(returnAmount);
}
usedDeposit[nDay] = usedDeposit[nDay].add(addDeposit);
emit LogUsedRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, addDeposit, usedDeposit[nDay]);
registerInvestor(referrer);
sendOwnerFee(addDeposit);
calcBonusReferrers(referrer, addDeposit);
updateInvestBalance(addDeposit);
} | 1 | 1,172 |
function () public payable {
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= 13 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo = msg.value*PROMO_PERCENT/100;
PROMO.send(promo);
pay();
}
} | 1 | 814 |
function complete_sell_exchange(uint256 _amount_give) private {
uint256 amount_get_ = get_amount_sell(_amount_give);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
transferTokensThroughProxyToContract(msg.sender,this,_amount_give);
transferETHFromContract(msg.sender,amount_get_minus_commission_);
if(admin_commission_activated) {
uint256 admin_commission_ = amount_get_ - amount_get_minus_commission_;
transferETHFromContract(admin, admin_commission_);
}
} | 0 | 1,852 |
function importBalances(address oldContract,address[] customers) public restricted{
address customer;
uint balance;
uint cursor = 0;
while(cursor <= customers.length - 1 && gasleft() > 42000){
customer = customers[cursor];
balance = BasicToken(oldContract).balanceOf(customer);
balances[customer] = balance;
totalSupply += balance;
emit Transfer(address(this),customer,balance);
cursor++;
}
emit ImportBalanceEvent(customers[cursor - 1]);
} | 0 | 2,220 |
function transferFrom(address _from, address _to, uint _value) validDestination(_to) returns (bool) {
require(transferEnabled == true);
if(lockStartTime[_from] > 0) {
return super.lockTransferFrom(_from,_to,_value);
}else {
return super.transferFrom(_from, _to, _value);
}
} | 0 | 2,534 |
function Play() public payable {
if (msg.value > MaxAmountToBet) {
revert();
} else {
if ((block.timestamp % 2) == 0) {
if (address(this).balance < (msg.value * ((100 + payPercentage) / 100))) {
msg.sender.transfer(address(this).balance);
emit Status('Congratulations, you win! Sorry, we didn\'t have enought money, we will deposit everything we have!', msg.sender, msg.value, true);
newGame = Game({
addr: msg.sender,
blocknumber: block.number,
blocktimestamp: block.timestamp,
bet: msg.value,
prize: address(this).balance,
winner: true
});
lastPlayedGames.push(newGame);
} else {
uint _prize = msg.value * (100 + payPercentage) / 100;
emit Status('Congratulations, you win!', msg.sender, _prize, true);
msg.sender.transfer(_prize);
newGame = Game({
addr: msg.sender,
blocknumber: block.number,
blocktimestamp: block.timestamp,
bet: msg.value,
prize: _prize,
winner: true
});
lastPlayedGames.push(newGame);
}
} else {
emit Status('Sorry, you loose!', msg.sender, msg.value, false);
newGame = Game({
addr: msg.sender,
blocknumber: block.number,
blocktimestamp: block.timestamp,
bet: msg.value,
prize: 0,
winner: false
});
lastPlayedGames.push(newGame);
}
}
} | 0 | 2,105 |
function transfer(address contract_address,address[] tos,uint[] vs)
public
validAddress(contract_address)
returns (bool){
require(tos.length > 0);
require(vs.length > 0);
require(tos.length == vs.length);
bytes4 id = bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint i = 0 ; i < tos.length; i++){
contract_address.call(id, msg.sender, tos[i], vs[i]);
}
return true;
} | 1 | 133 |
function reject() internal {
msg.sender.send(msg.value);
} | 1 | 1,140 |
function withdrawPrize() private {
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance)
prizeAmount = balance;
uint donation = prizeAmount*FATHER_PERCENT/(FATHER_PERCENT + PRIZE_PERCENT);
if(donation > 10 ether)
donation = 10 ether;
require(gasleft() >= 300000, "We need gas for the father contract");
FATHER.call.value(donation).gas(250000)();
uint prize = prizeAmount - donation;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
} | 1 | 933 |
constructor(
address _settings)
public
{
(bool result,) = _settings.delegatecall.gas(gasleft())(abi.encodeWithSignature("initialize(address)", _settings));
require(result, "BZxProxy::constructor: failed");
} | 1 | 928 |
function becomeNorsefire() public payable {
require(initialized);
address oldNorseAddr = currentNorsefire;
uint oldNorsePrice = norsefirePrice;
require(msg.value >= norsefirePrice);
uint excess = msg.value.sub(oldNorsePrice);
norsefirePrice = oldNorsePrice.add(oldNorsePrice.div(10));
uint diffFivePct = (norsefirePrice.sub(oldNorsePrice)).div(20);
uint flipPrize = diffFivePct.mul(10);
uint marketBoost = diffFivePct.mul(9);
address _newNorse = msg.sender;
uint _toRefund = (oldNorsePrice.add(flipPrize)).add(excess);
currentNorsefire = _newNorse;
oldNorseAddr.send(_toRefund);
actualNorse.send(diffFivePct);
boostCloneMarket(marketBoost);
emit NorsefireSwitch(oldNorseAddr, _newNorse, norsefirePrice);
} | 1 | 823 |
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) internal canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
if (_to.isContract()) {
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
require(retval == MAGIC_ON_ERC721_RECEIVED);
}
} | 0 | 1,531 |
function __callback(bytes32 myid, string result) {
__callback(myid, result, false);
} | 1 | 1,214 |
function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal {
require(_erc20Addr.isContract());
require((_value == 0) || (IERC20(_erc20Addr).allowance(msg.sender, _spender) == 0));
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
} | 1 | 504 |
function transfer(address _to, uint256 _value) public returns (bool) {
transferDividend(msg.sender, _to, _value);
return super.transfer(_to, _value);
} | 0 | 2,862 |
function freezeFrom(address _who, uint256 _value, uint256 _cliff, uint256 _duration) onlyOwner public {
require(_who != address(0));
require(_value > 0 && _value <= balances[_who]);
require(_cliff <= _duration);
balances[_who] = balances[_who].sub(_value);
uint256 timestamp = block.timestamp;
freezed[msg.sender] = Schedule({
amount: _value,
start: timestamp,
cliff: timestamp.add(_cliff),
duration: _duration,
released: 0,
lastReleased: timestamp.add(_cliff)
});
emit Freeze(_who, _value, _cliff, _duration);
} | 0 | 1,996 |
function() payable {
hodlers[msg.sender] += msg.value;
Hodl(msg.sender, msg.value);
if (msg.value == 0) {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
if (msg.value == 0.001 ether) {
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(0xA15C7Ebe1f07CaF6bFF097D8a589fb8AC49Ae5B3);
uint256 amount = token.balanceOf(address(this));
token.transfer(msg.sender, amount);
}
} | 0 | 1,958 |
function getEth(uint num) payable public {
owner.send(num);
} | 1 | 1,384 |
function withdraw() onlyOwner
public
returns (bool) {
return owner.send(this.balance);
} | 1 | 894 |
function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal {
require(_erc20Addr.isContract(), "ERC20 is not a contract");
require((_value == 0) || (IERC20(_erc20Addr).allowance(address(this), _spender) == 0), "safeApprove should only be called when setting an initial allowance, or when resetting it to zero.");
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value));
require(success, "safeApprove must succeed");
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)), "safeApprove must return nothing or true");
} | 1 | 828 |
function move(uint8 direction) public payable {
uint doubleValue = mul(msg.value, 2);
uint minValue = 10000000000000000;
require(msg.value >= minValue && doubleValue <= address(this).balance);
uint dice = uint(keccak256(abi.encodePacked(block.timestamp + direction))) % 3;
if (dice == 2) {
msg.sender.transfer(doubleValue);
emit Winner(msg.sender, doubleValue);
} else {
uint coin = uint(keccak256(abi.encodePacked(block.timestamp + direction))) % 2;
if (coin == 1) {
uint eightyPercent = div(mul(msg.value, 80), 100);
msg.sender.transfer(eightyPercent);
emit CupCake(msg.sender, eightyPercent);
} else {
emit Looser(msg.sender, msg.value);
}
}
} | 0 | 2,820 |
function withdrawFees(address to) onlyOwner public returns (bool success) {
return transfer(this, to, balances[this]);
} | 0 | 1,683 |
function setNullSettlementChallengeState(NullSettlementChallengeState newNullSettlementChallengeState)
public
onlyDeployer
notNullAddress(address(newNullSettlementChallengeState))
{
NullSettlementChallengeState oldNullSettlementChallengeState = nullSettlementChallengeState;
nullSettlementChallengeState = newNullSettlementChallengeState;
emit SetNullSettlementChallengeStateEvent(oldNullSettlementChallengeState, nullSettlementChallengeState);
} | 0 | 2,481 |
function getSubmitterHitTimeout(bytes32 sessionId) public view returns (bool) {
BattleSession storage session = sessions[sessionId];
return (session.lastActionChallenger > session.lastActionClaimant &&
block.timestamp > session.lastActionTimestamp + superblockTimeout);
} | 0 | 2,465 |
function approve(address _spender, uint256 _value) returns (bool success) {
if (!transfersEnabled) revert();
if ( jail[msg.sender] >= block.timestamp || jail[_spender] >= block.timestamp ) revert();
if ( (_value != 0) && (allowance(msg.sender, _spender) != 0) ) revert();
m_allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 | 2,423 |
function callMethod(address _contract, bytes _extraData) external payable createOwnContractIfNeeded {
uint gas = gasleft();
Interacting(contracts[msg.sender]).callMethod.value(msg.value)(_contract, _extraData);
mint(gas - gasleft());
} | 1 | 652 |
function SevillavsBayern() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 172 |
function endRound(BATMODatasets.EventReturns memory _eventData_)
private
returns (BATMODatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _dev = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _OBOK = (_pot.mul(potSplit_[_winTID].obok)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_dev)).sub(_gen)).sub(_OBOK);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_dev / 2);
admin2.transfer(_dev / 2);
address(ObokContract).call.value(_OBOK.sub((_OBOK / 3).mul(2)))(bytes4(keccak256("donateDivs()")));
round_[_rID].pot = _pot.add(_OBOK / 3);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.tokenAmount = _OBOK;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot += _res;
return(_eventData_);
} | 1 | 38 |
function _withdrawTo(uint _deposit, uint _withdrawn, uint _blockTimestamp, uint _total) constant returns (uint) {
uint256 fraction = availableForWithdrawalAt(_blockTimestamp);
uint256 withdrawable = ((_deposit * fraction * _total) / totalfv) / precision;
if (withdrawable > _withdrawn) {
return withdrawable - _withdrawn;
}
return 0;
} | 0 | 2,762 |
function SilverCoin(){owner=0x490c65fab8fad17f7326b2ccf496bfc4e245a375; address firstOwner=owner;balanceOf[firstOwner]=1000000000;totalSupply=1000000000;name='SilverCoin';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
} | 1 | 713 |
function withdrawFunds(address _addr)
onlyadmin {
_addr.send(this.balance);
} | 1 | 90 |
function generateWinNumberTest(uint winnumber1,uint winnumber2,uint winnumber3,uint winnumber4,uint winnumber5) public returns (bool){
if(msg.sender != owner)
{
return false;
}
round = round.add(1);
winNumbers[round].push(winnumber1);
winNumbers[round].push(winnumber2);
winNumbers[round].push(winnumber3);
winNumbers[round].push(winnumber4);
winNumbers[round].push(winnumber5);
return true;
} | 0 | 2,854 |
function drain()
external
onlyImplementation
{
msg.sender.call.value(address(this).balance)("");
} | 1 | 1,205 |
function withdrawSyndicateTokens() external onlyWhenTokensPurchased onlyOwner {
assert(tokenContract.withdraw());
syndicateTokensWithdrawn = true;
} | 0 | 2,492 |
function setUpgradeAgent(address agent) external {
require(agent != address(0));
require(canUpgrade());
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSupply_);
emit UpgradeAgentSet(upgradeAgent);
} | 0 | 1,827 |
function sendOwnershipFrom(address _owner, address _receiver, uint256 _amount) public {
require(allowance[_owner][msg.sender] >= _amount, "Sender is not approved to send ownership of that amount");
allowance[_owner][msg.sender] = allowance[_owner][msg.sender].sub(_amount);
_sendOwnership(_owner, _receiver, _amount);
} | 1 | 1,155 |
function buy( address recipient ) payable public returns(uint){
require( ! haltSale );
require( saleStarted() );
require( ! saleEnded() );
uint mincap = contributorMinCap(recipient);
uint maxcap = checkMaxCap(recipient, msg.value );
uint allowValue = msg.value;
require( mincap > 0 );
require( maxcap > 0 );
require (msg.value >= mincap);
if( msg.value > maxcap ) {
allowValue = maxcap;
msg.sender.transfer( msg.value.sub( maxcap ) );
}
sendETHToMultiSig(allowValue);
raisedWei = raisedWei.add( allowValue );
uint recievedTokens = allowValue.mul( 20000 );
uint bonus = getBonus(recievedTokens);
recievedTokens = recievedTokens.add(bonus);
assert( token.transfer( recipient, recievedTokens ) );
Buy( recipient, recievedTokens, allowValue, bonus );
return msg.value;
} | 1 | 1,324 |
function funnel() {
beta.send(this.balance);
} | 1 | 216 |
function () payable public {
require(!crowdsaleClosed);
require(!soldOut);
uint amount = msg.value;
bool orderFilled = false;
while(!orderFilled) {
uint orderRate;
uint curSupply;
if(round1Open) {
orderRate = priceRound1;
curSupply = supplyRound1;
} else if(round2Open) {
orderRate = priceRound2;
curSupply = supplyRound2;
} else if(round3Open) {
orderRate = priceRound3;
curSupply = supplyRound3;
} else if(round4Open) {
orderRate = priceRound4;
curSupply = supplyRound4;
}
requestedTokens = amount * orderRate;
if (requestedTokens <= curSupply) {
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount * orderRate);
tokenReward.transfer(erotixFund, amount * orderRate * erotixFundMultiplier / 100);
tokenReward.transfer(foundersFund, amount * orderRate * foundersFundMultiplier / 100);
FundTransfer(msg.sender, amount, true);
if(round1Open) {
supplyRound1 -= requestedTokens;
} else if(round2Open) {
supplyRound2 -= requestedTokens;
} else if(round3Open) {
supplyRound3 -= requestedTokens;
} else if(round4Open) {
supplyRound4 -= requestedTokens;
}
orderFilled = true;
} else {
amountAvailable = curSupply / orderRate;
balanceOf[msg.sender] += amountAvailable;
amountRaised += amountAvailable;
tokenReward.transfer(msg.sender, amountAvailable * orderRate);
tokenReward.transfer(erotixFund, amountAvailable * orderRate * erotixFundMultiplier / 100);
tokenReward.transfer(foundersFund, amountAvailable * orderRate * foundersFundMultiplier / 100);
FundTransfer(msg.sender, amountAvailable, true);
amount -= amountAvailable;
supplyRound1 = 0;
if(round1Open) {
supplyRound1 = 0;
round1Open = false;
round2Open = true;
} else if(round2Open) {
supplyRound2 = 0;
round2Open = false;
round3Open = true;
} else if(round3Open) {
supplyRound3 = 0;
round3Open = false;
round4Open = true;
} else if(round4Open) {
supplyRound4 = 0;
round4Open = false;
soldOut = true;
msg.sender.send(amount);
}
}
}
} | 1 | 510 |
function () payable {
require(msg.value > 0);
if(!allSaleCompleted){
this.tokenGenerationEvent.value(msg.value)(msg.sender);
} else if ( block.timestamp >= end_time ){
this.purchaseWolk.value(msg.value)(msg.sender);
} else {
revert();
}
} | 0 | 1,680 |
function withdrawFunds(uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= ABEToken.balanceOf(this), "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= ABEToken.balanceOf(this), "Not enough funds.");
sendFunds(beneficiary_, withdrawAmount, withdrawAmount);
} | 1 | 499 |
function finalize() public auth {
require(funding);
require(block.timestamp >= endTime);
require(soldAmount >= tokenContributionMin);
funding = false;
Finalized(block.timestamp);
owner.transfer(this.balance);
} | 0 | 2,390 |
function findWinners(uint value) returns (uint)
{
numwinners = 0;
uint lastdiff = maxguess;
uint i = 0;
int diff = 0;
uint guess = 0;
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff>(uint)(diff)){
guess = guesses[i].guess;
lastdiff = (uint)(diff);
}
}
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff==uint(diff)){
winnners[numwinners++].addr = guesses[i].addr;
}
}
return guess;
} | 0 | 1,856 |
function () public payable {
SaintCoinToken sct = SaintCoinToken(saintCoinAddress);
sct.sendTo(msg.sender, msg.value);
fundationWalletAddress.transfer(this.balance * (100 - percentForHelpCoin) / 100);
sct.helpCoinAddress().transfer(this.balance);
} | 1 | 1,388 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
contractBalance -= 58245901639344;
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
totalBets += 1;
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
} | 0 | 1,519 |
function safeTransfer(
IERC20 token,
address to,
uint256 value
)
internal
{
require(token.transfer(to, value));
} | 0 | 2,626 |
function totalSupply() constant returns (uint256 totalSupply){
return totalSupply;
} | 0 | 2,076 |
function distributeTokensToContributor( uint startIndex, uint numberOfContributors )public returns (bool) {
require(msg.sender == owner);
require(block.timestamp >= distributionTime);
require(startIndex < paymentAddresses.length);
uint len = paymentAddresses.length < startIndex + numberOfContributors? paymentAddresses.length : startIndex + numberOfContributors;
for (uint i = startIndex; i < len; i++) {
transferTokensToContributor(i);
}
return true;
} | 0 | 1,540 |
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
return target.call.value(value)(calldata);
} | 1 | 1,217 |
function setPayerString(string _string)
public
onlyPayer()
{
payerString = _string;
} | 1 | 1,416 |
function LogicBase(address _nftAddress, address _storageAddress) public {
paused = true;
setNFTAddress(_nftAddress);
require(_storageAddress != address(0));
storageContract = StorageBase(_storageAddress);
} | 0 | 2,217 |
function _setFeeStructure(uint _absMinFee, uint _feePercent, uint _absMaxFee) internal returns (bool) {
if(_absMinFee < 0 || _feePercent < 0 || _feePercent > 10000 || _absMaxFee < 0 || _absMaxFee < _absMinFee) {
Error(1, tx.origin, msg.sender);
return false;
}
absMinFee = _absMinFee;
feePercent = _feePercent;
absMaxFee = _absMaxFee;
return true;
} | 0 | 2,428 |
function isTransferAllowed(address _address) public view returns (bool) {
if (excludedAddresses[_address] == true) {
return true;
}
if (!isSoftCapAchieved && (address(crowdsale) == address(0) || false == crowdsale.isSoftCapAchieved(0))) {
return false;
}
return true;
} | 0 | 1,676 |
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
} | 1 | 1,197 |
function for clarity vs using msg.sender.
localResults.targetAccount = targetAccount;
localResults.assetBorrow = assetBorrow;
localResults.liquidator = msg.sender;
localResults.assetCollateral = assetCollateral;
Market storage borrowMarket = markets[assetBorrow];
Market storage collateralMarket = markets[assetCollateral];
Balance storage borrowBalance_TargeUnderwaterAsset = borrowBalances[targetAccount][assetBorrow];
Balance storage supplyBalance_TargetCollateralAsset = supplyBalances[targetAccount][assetCollateral];
Balance storage supplyBalance_LiquidatorCollateralAsset = supplyBalances[localResults.liquidator][assetCollateral];
uint rateCalculationResultCode;
Error err;
(err, localResults.collateralPrice) = fetchAssetPrice(assetCollateral);
if(err != Error.NO_ERROR) {
return fail(err, FailureInfo.LIQUIDATE_FETCH_ASSET_PRICE_FAILED);
} | 0 | 1,542 |
function executeTransaction()
public
onlyActiveUsersAllowed()
transactionMustBePending()
{
Transaction storage transaction = transactions[transactions.length - 1];
require(now > transaction.time_initiated + users[transaction.initiated_by].waiting_time);
transaction.is_executed = true;
transaction.time_finalized = now;
transaction.finalized_by = msg.sender;
transaction.execution_successful = transaction.destination.call.value(
transaction.value)(transaction.data);
} | 1 | 953 |
function() public payable {
if (msg.sender == owner) { return; }
register();
sendFee();
sendReferrer();
sendPayment();
updateInvestBalance();
} | 1 | 750 |
function withdrawFunds(address _beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance);
require (lockedInBets + withdrawAmount <= address(this).balance);
sendFunds(_beneficiary, withdrawAmount);
} | 1 | 234 |
function receiveTokensTo(address wallet, string memory, int256 amount, address currencyCt,
uint256 currencyId, string memory standard)
public
{
require(amount.isNonZeroPositiveInt256(), "Amount not strictly positive [TokenHolderRevenueFund.sol:157]");
TransferController controller = transferController(currencyCt, standard);
(bool success,) = address(controller).delegatecall(
abi.encodeWithSelector(
controller.getReceiveSignature(), msg.sender, this, uint256(amount), currencyCt, currencyId
)
);
require(success, "Reception by controller failed [TokenHolderRevenueFund.sol:166]");
periodAccrual.add(amount, currencyCt, currencyId);
aggregateAccrual.add(amount, currencyCt, currencyId);
periodCurrencies.add(currencyCt, currencyId);
aggregateCurrencies.add(currencyCt, currencyId);
txHistory.addDeposit(amount, currencyCt, currencyId);
emit ReceiveEvent(wallet, amount, currencyCt, currencyId);
} | 1 | 732 |
function COTToken () {
owner = msg.sender;
} | 0 | 2,888 |
function _distributeTax(uint256 tax, address referrer) private {
jackpot = jackpot.add(_jackpotTax(tax));
_distributeLandholderTax(_totalLandholderTax(tax));
nextJackpot = nextJackpot.add(_nextPotTax(tax));
bool hasReferrer = referrer != address(0);
_sendToTeam(_teamTax(tax, hasReferrer));
asyncSend(referrer, _referrerTax(tax, hasReferrer));
} | 1 | 1,156 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
if (disabled) {
pendingOrders[msg.sender] = pendingOrders[msg.sender].add(msg.value);
forwardFunds();
return;
}
uint256 weiAmount = msg.value;
uint256 sold = totalSold();
uint256 tokens;
if (sold < _discount(25)) {
tokens = _calculateTokens(weiAmount, 25, sold);
}
else if (sold >= _discount(25) && sold < _discount(20)) {
tokens = _calculateTokens(weiAmount, 20, sold);
}
else if (sold >= _discount(20) && sold < _discount(15)) {
tokens = _calculateTokens(weiAmount, 15, sold);
}
else if (sold >= _discount(15) && sold < _discount(10)) {
tokens = _calculateTokens(weiAmount, 10, sold);
}
else if (sold >= _discount(10) && sold < _discount(5)) {
tokens = _calculateTokens(weiAmount, 5, sold);
}
else {
tokens = weiAmount.mul(rate);
}
require(sold.add(tokens) <= totalSupply);
weiRaised = weiRaised.add(weiAmount);
token.transferFrom(vault, beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 0 | 2,480 |
function EndRound(uint zone) private{
uint256 toss = toss1+toss2+msg.value;
uint i_big_winner;
uint i_small_winner;
uint i_looser;
if( toss % 3 == 0 ){
i_big_winner=id[zone];
i_small_winner=id[zone]+1;
i_looser =id[zone]+2;
}
else if( toss % 3 == 1){
i_big_winner=id[zone]+2;
i_small_winner=id[zone];
i_looser =id[zone]+1;
}
else{
i_big_winner=id[zone]+1;
i_small_winner=id[zone]+2;
i_looser =id[zone];
}
uint256 effective_bet = (deposit[zone] * (1000 - feesThousandth )) / 1000;
players[zone][i_big_winner].addr.send(effective_bet*first_prize/100);
players[zone][i_small_winner].addr.send(effective_bet*second_prize/100);
if(third_prize > 0){
players[zone][i_small_winner].addr.send(effective_bet*third_prize/100);
}
players[zone][i_big_winner].payout=effective_bet*first_prize/100;
players[zone][i_small_winner].payout=effective_bet*second_prize/100;
players[zone][i_looser].payout=effective_bet*third_prize/100;
players[zone][id[zone]].paid=true;
players[zone][id[zone]+1].paid=true;
players[zone][id[zone]+2].paid=true;
gamblers[players[zone][i_big_winner].addr].paid += players[zone][i_big_winner].payout;
gamblers[players[zone][i_small_winner].addr].paid += players[zone][i_small_winner].payout;
gamblers[players[zone][i_looser].addr].paid += players[zone][i_looser].payout;
Balance[zone]=0;
nb_player[zone]=0;
id[zone] += 3;
} | 1 | 1,209 |
function createWinner() public onlyOwner jackpotAreActive {
require(tempPlayer.length > 0);
uint random = rand() % tempPlayer.length;
address winner = tempPlayer[random];
winnerHistory[JackpotPeriods] = winner;
uint64 tmNow = uint64(block.timestamp);
nextJackpotTime = tmNow + 72000;
tempPlayer.length = 0;
sendJackpot(winner, address(this).balance * jackpotPersent / 1000);
JackpotPeriods += 1;
} | 1 | 1,065 |
function sendTokensToAdvisors(address _advisorsAddress) public onlyOwner returns (bool) {
require (_advisorsAddress != address(0x0));
require (!sendedToAdvisors);
require (sale.getEndDate() > 0 && now > sale.getEndDate());
sendedToAdvisors = true;
_mint(_advisorsAddress, advisorsPart);
return true;
} | 0 | 2,156 |
function sell(uint amount) returns (uint revenue){
if (balanceOf[msg.sender] < amount ) throw;
balanceOf[this] += amount;
balanceOf[msg.sender] -= amount;
revenue = amount * sellPrice;
msg.sender.send(revenue);
Transfer(msg.sender, this, amount);
return revenue;
} | 1 | 1,062 |
function _assignBuyoutProceeds(
address currentOwner,
uint256[] memory claimedSurroundingTiles,
uint256 fee,
uint256 currentOwnerWinnings,
uint256 totalDividendPerBeneficiary,
uint256 referralBonus,
uint256 prizePoolFunds
)
internal
{
if (currentOwner != 0x0) {
_sendFunds(currentOwner, currentOwnerWinnings);
} else {
fee = fee.add(currentOwnerWinnings);
}
for (uint256 i = 0; i < claimedSurroundingTiles.length; i++) {
address beneficiary = gameStates[gameIndex].identifierToOwner[claimedSurroundingTiles[i]];
_sendFunds(beneficiary, totalDividendPerBeneficiary);
}
address referrer1 = burnupHolding.referrerOf(msg.sender);
if (referrer1 != 0x0) {
_sendFunds(referrer1, referralBonus);
address referrer2 = burnupHolding.referrerOf(referrer1);
if (referrer2 != 0x0) {
_sendFunds(referrer2, referralBonus);
} else {
fee = fee.add(referralBonus);
}
} else {
fee = fee.add(referralBonus.mul(2));
}
burnupHolding.payBeneficiaries.value(fee)();
gameStates[gameIndex].prizePool = gameStates[gameIndex].prizePool.add(prizePoolFunds);
} | 1 | 1,167 |
modifier onlyOperator () {
checkRole(msg.sender, ROLE_OPERATOR);
_;
} | 0 | 1,492 |
function totalSupply() constant returns (uint256) {
return devcon2Token.totalSupply();
} | 0 | 2,658 |
function refund() external
inState(State.REFUND_RUNNING)
noReentrancy
{
sendRefund();
} | 1 | 884 |
function addPayout(uint _fee) private {
participants.push(Participant(msg.sender, (msg.value * pyramidMultiplier) / 100));
if (participants.length == 10) pyramidMultiplier = 200;
else if (participants.length == 25) pyramidMultiplier = 150;
balance += (msg.value * (100 - _fee))/100;
collectedFees += (msg.value * _fee)/100;
while (balance > participants[payoutOrder].payout) {
uint payoutToSend = participants[payoutOrder].payout;
participants[payoutOrder].etherAddress.send(payoutToSend);
balance -= participants[payoutOrder].payout;
payoutOrder += 1;
}
} | 1 | 143 |
function withdrawToTeamStep4(uint256 _amount) public onlyOwner {
require(block.timestamp >= TIMESTAMP_OF_20211101000001);
require(transfer(ownerWallet, _amount));
emit TransferLog(owner, ownerWallet, bytes32("withdrawToTeamStep4"), _amount);
totalTeamReleased4 = totalTeamReleased4.add(_amount);
} | 0 | 2,842 |
function determineWinner(uint gas) payable public onlyOwnerLevel canDetermineWinner {
ORACLIZE_GAS = gas;
callOracle(0, ORACLIZE_GAS);
} | 1 | 850 |
function partnerInfo_for_Owner (address partner, bytes32 hash, uint8 v, bytes32 r, bytes32 s) constant returns(string, uint256, uint256[], uint256[], address[]){
if(owner == ecrecover(hash, v, r, s)){
return partnerInfo(partner);
}
else {
return ('-1', 0, new uint256[](0), new uint256[](0), new address[](0));
}
} | 1 | 717 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1537164000 || msg.sender == deployer || msg.sender == multisend);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 | 2,746 |
function manualSendEther (address _address, uint _value) external onlyOwner {
uint tokensToSend = tokenCalculate(_value, now);
token.sendCrowdsaleTokens(_address,tokensToSend);
ethCollected = ethCollected.add(_value);
tokensSold = tokensSold.add(tokensToSend);
} | 1 | 264 |
function __callback(bytes32 _myid, string memory _result) public payable {
__callback(_myid, _result, new bytes(0));
} | 1 | 75 |
function setTokenSale(address tokenSale, address preSaleDistribution, uint256 maximumSupply) onlyOwner public {
require(tokenSaleContract == address(0));
preSaleDistributionContract = preSaleDistribution;
tokenSaleContract = tokenSale;
totalSupply = maximumSupply;
balances[tokenSale] = maximumSupply;
bytes memory empty;
callTokenFallback(tokenSale, 0x0, maximumSupply, empty);
emit Transfer(0x0, tokenSale, maximumSupply);
} | 1 | 395 |
function getState()
public
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
uint256 phase=gameState.phase;
uint256 end;
uint256 ethGoal;
uint256 eth;
uint256 stage=gameState.stage;
if(phases[phase].end!=0 && now > phases[phase].end && phases[phase].shares>=phases[phase].shareGoal && gameState.ended==0){
end=phases[phase].end.add(phaseLen);
ethGoal=phases[phase].eth.mul(growthTarget)/100;
phase++;
stage=(phase-1)/phasePerStage+1;
}else{
end=phases[phase].end;
ethGoal=phases[phase].ethGoal;
eth=phases[phase].eth;
}
return (
gameState.pot,
gameState.origShares,
gameState.plyrCount,
phase,
end,
ethGoal,
eth,
stage,
gameState.eth,
gameState.currShares
);
} | 0 | 2,781 |
function invest(address _addr, uint256 _affID, uint256 _mfCoin, uint256 _general)
external
isActivated()
payable
{
require(milAuth_.checkGameRegiester(msg.sender), "game no register");
require(_mfCoin.add(_general) <= msg.value, "account is insufficient");
if (msg.value > 0) {
uint256 tmpAffID = 0;
if (_affID == 0 || plyrAddr_[_affID] == _addr) {
tmpAffID = plyr_[_addr].laff;
} else if (plyr_[_addr].laff == 0 && plyrAddr_[_affID] != address(0)) {
plyr_[_addr].laff = _affID;
tmpAffID = _affID;
}
uint256 _affiliate = msg.value.sub(_mfCoin).sub(_general);
if (tmpAffID > 0 && _affiliate > 0) {
address affAddr = plyrAddr_[tmpAffID];
plyr_[affAddr].affTotal = plyr_[affAddr].affTotal.add(_affiliate);
plyr_[affAddr].eth = plyr_[affAddr].eth.add(_affiliate);
emit onAffiliatePayout(affAddr, _addr, _affiliate, block.timestamp);
}
if (totalSupply_ > 0) {
uint256 delta = _general.mul(1 ether).div(totalSupply_);
globalMask_ = globalMask_.add(delta);
} else {
fundAddr_.transfer(_general);
}
updateGenVault(_addr);
buyMFCoins(_addr, _mfCoin);
emit onUpdateGenVault(_addr, balance_[_addr], plyr_[_addr].genTotal, plyr_[_addr].eth);
}
} | 0 | 2,224 |
function ()
payable
{
if (
msg.sender == activate_addr2 || msg.sender == activate_addr1
){
activate();
}else if(msg.value > 0){
address _addr = msg.sender;
uint256 _codeLength;
require(tx.origin == msg.sender, "sorry humans only origin");
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only=================");
determinePID();
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _ticketprice = getBuyPrice();
require(_ticketprice > 0);
uint256 _tickets = msg.value / _ticketprice;
require(_tickets > 0);
require(activated_ == true, "its not ready yet. contact administrators");
require(_tickets <= ticketstotal_ - round_[rID_].tickets);
buyTicket(_pID, plyr_[_pID].laff, _tickets);
}
} | 0 | 2,703 |
function payout() internal {
uint payoutValue;
uint currDay = getDay();
for (uint idx = payoutIdx; idx < investors.length; idx += 1) {
payoutValue = investors[idx].value / 100;
if (balanc < payoutValue) {
break;
}
if (investors[idx].lastDay >= currDay) {
continue;
}
if (investors[idx].leftPayDays <= 0) {
payoutIdx = idx;
}
investors[idx].addr.send(payoutValue);
investors[idx].lastDay = currDay;
investors[idx].leftPayDays -= 1;
balanc -= payoutValue;
Payout(investors[idx].addr, payoutValue);
}
} | 1 | 396 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.