func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function isNotContract(address addr) internal view returns(bool) {
uint length;
assembly { length := extcodesize(addr) }
return length == 0;
}
| 0 | 16,077 |
function doPreAllocations() external onlyOwner returns (bool) {
require(preAllocationsPending);
token.transfer(_promo, PROMO_TOKEN_AMOUNT);
_allocateTokens(_founder_one, TEAM_TOKEN_AMOUNT);
_allocateTokens(_founder_two, TEAM_TOKEN_AMOUNT);
_allocateTokens(_reserve, RESERVE_TOKEN_AMOUNT);
totalAllocated = totalAllocated.add(PROMO_TOKEN_AMOUNT);
preAllocationsPending = false;
return true;
}
| 1 | 3,998 |
function () public payable {
require(msg.value > 0);
holders.push(msg.sender);
holder_balance[msg.sender] += msg.value;
}
| 0 | 9,766 |
function createTokens() public saleIsOn payable {
uint tokens = rate.mul(msg.value).div(1 ether);
uint finishdays=90-now.sub(start).div(1 days);
uint bonusTokens = 0;
if(finishdays < 0) {
finishdays=0;
}
bonusTokens = tokens.mul(finishdays).div(100);
tokens = tokens.add(bonusTokens);
token.mint(msg.sender, tokens);
balances[msg.sender] = balances[msg.sender].add(msg.value);
if (!isOneToken){
tokens = tokens.add(1000000000000000000);
isOneToken=true;
}
token.mint(restricted, tokens);
balances[restricted] = balances[restricted].add(msg.value);
restricted.transfer(this.balance);
}
| 1 | 3,741 |
function SirinCrowdsale(uint256 _startTime,
uint256 _endTime,
address _wallet,
address _walletTeam,
address _walletOEM,
address _walletBounties,
address _walletReserve,
SirinSmartToken _sirinSmartToken,
RefundVault _refundVault)
public
Crowdsale(_startTime, _endTime, EXCHANGE_RATE, _wallet, _sirinSmartToken) {
require(_walletTeam != address(0));
require(_walletOEM != address(0));
require(_walletBounties != address(0));
require(_walletReserve != address(0));
require(_sirinSmartToken != address(0));
require(_refundVault != address(0));
walletTeam = _walletTeam;
walletOEM = _walletOEM;
walletBounties = _walletBounties;
walletReserve = _walletReserve;
token = _sirinSmartToken;
refundVault = _refundVault;
}
| 0 | 11,700 |
function startInvasion(uint _areaId, uint[] _zombieId) public onlyOwnerOf(_zombieId){
require(areas[_areaId].TotallimitTeamCount >= areas[_areaId].TotalTeamCount + 1);
require(areas[_areaId].isOpen);
require(areas[_areaId].TeamMemberlimitCount >= _zombieId.length);
bytes32 teamHash = block.blockhash(block.number-1);
for(uint16 i = 0; i<_zombieId.length; i++){
require(now > zombies[_zombieId[i]].readyTime);
require(!zombies[_zombieId[i]].notAtHome);
teamHash = keccak256(teamHash,now,_areaId,zombiemain.seeZombieDna(_zombieId[i]));
zombies[_zombieId[i]].notAtHome = true;
zombies[_zombieId[i]].readyTime = uint32(now + areas[_areaId].duration);
}
for(uint16 a = 0; a<areas[_areaId].roletype.length; a++){
if(areas[_areaId].roletype[a] == 99) continue;
if(zombiemain.seeZombieRole(_zombieId[a]) != areas[_areaId].roletype[a]) revert();
}
areas[_areaId].TotalTeamCount ++;
require(teams[teamHash].areaID == 0);
teams[teamHash] = Team(false,_areaId,_zombieId,uint32(now+areas[_areaId].duration),msg.sender,teamHash,block.number + 1);
StartInvasion(teamHash, _areaId, _zombieId, msg.sender);
}
| 1 | 2,719 |
function openModifyCountdown()
senderVerify()
isDeveloperAddr()
public
{
require(modifyCountdown == false, "Time service is already open");
modifyCountdown = true;
}
| 0 | 18,715 |
function proxyChangeCrowdsaleMaster(address _newMaster)
public
returns (bool)
{
require(msg.sender == getContractAddress("PoaManager"));
require(_newMaster != address(0));
require(poaCrowdsaleMaster != _newMaster);
require(isContract(_newMaster));
address _oldMaster = poaCrowdsaleMaster;
poaCrowdsaleMaster = _newMaster;
emit ProxyUpgraded(_oldMaster, _newMaster);
getContractAddress("PoaLogger").call(
abi.encodeWithSignature(
"logProxyUpgraded(address,address)",
_oldMaster,
_newMaster
)
);
return true;
}
| 0 | 12,713 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool success) {
if (balance[msg.sender] >= _value && balance[_to] + _value > balance[_to]) {
balance[msg.sender] -= _value;
balance[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
| 0 | 14,870 |
modifier isHuman() {
address _customerAddress = msg.sender;
if (_customerAddress != address(fairExchangeContract)){
require(_customerAddress == tx.origin);
_;
}
}
| 0 | 16,370 |
function transferDirectly(address from, address to, uint tokensAmount) private {
balances[from] = balances[from].sub(tokensAmount);
balances[to] = balances[to].add(tokensAmount);
}
| 1 | 2,808 |
function depositToken(address _token, uint _amount) deprecable {
require(_token != 0);
if (!Token(_token).transferFrom(msg.sender, this, _amount)) {
revert();
}
tokens[_token][msg.sender] = safeAdd(tokens[_token][msg.sender], _amount);
Deposit(_token, msg.sender, _amount, tokens[_token][msg.sender]);
}
| 1 | 9,017 |
function ZANNI() {
balances[msg.sender] = 1000000000000000000000;
totalSupply = 1000000000000000000000;
name = "ZANNI";
decimals = 18;
symbol = "ZANNI";
unitsOneEthCanBuy = 10;
fundsWallet = msg.sender;
}
| 0 | 16,940 |
function miningResolve(uint256 _orderIndex, uint256 _seed)
external
onlyService
{
require(_orderIndex > 0 && _orderIndex < ordersArray.length);
MiningOrder storage order = ordersArray[_orderIndex];
require(order.tmResolve == 0);
address miner = order.miner;
require(miner != address(0));
uint64 chestCnt = order.chestCnt;
require(chestCnt >= 1 && chestCnt <= 10);
uint256 rdm = _seed;
uint16[9] memory attrs;
for (uint64 i = 0; i < chestCnt; ++i) {
rdm = _randBySeed(rdm);
attrs = _getFashionParam(rdm);
tokenContract.createFashion(miner, attrs, 2);
}
order.tmResolve = uint64(block.timestamp);
MiningResolved(_orderIndex, miner, chestCnt);
}
| 0 | 16,106 |
function withdrawBalances(address _to) public onlyCLevel {
_to.transfer(this.balance);
}
| 1 | 2,469 |
function deposit(address receiver, uint numTokens, bool chargeGas) public isAlive {
require(numTokens > 0);
uint value = safeMul(numTokens, 10000);
if (chargeGas) value = safeSub(value, msg.gas / 1000 * gasPrice);
assert(edg.transferFrom(msg.sender, address(this), numTokens));
balanceOf[receiver] = safeAdd(balanceOf[receiver], value);
playerBalance = safeAdd(playerBalance, value);
Deposit(receiver, numTokens, chargeGas);
}
| 1 | 3,738 |
function transferForMining(address to) external isOwner {
require(to != owner);
withdrawCoins(VaultName[uint256(VaultEnum.mining)], to);
}
| 0 | 13,481 |
function closeLotteryAndPickWinner() onlyOwner public {
require(isLotteryOpen == true);
isLotteryOpen = false;
uint256 winning_number = uint256(keccak256(block.blockhash(block.number - 1))) % num_tickets_current_round;
address winner = gamblers[winning_number];
masternode_referrer = winner;
uint256 exact_tokens = maths.myTokens();
maths.transfer(winner, exact_tokens);
numTokensInLottery = 0;
winner.transfer(address(this).balance);
}
| 1 | 362 |
function receiveApproval(address _from, uint256 _amount, address _token, bytes _data)
public
{
require(msg.sender == coinToken || msg.sender == cashToken);
address beneficiary;
assembly {
beneficiary := mload(add(_data,36))
}
require(_from == beneficiary);
address(this).delegatecall(_data);
_token; _amount;
}
| 1 | 6,924 |
modifier canDelegate() {
require(msg.sender == address(token) || (_isDebug && tx.origin == administrator));
_;
}
| 0 | 18,088 |
function refund(uint256 requestId) external returns(bool) {
QuantstampAuditData.AuditState state = auditData.getAuditState(requestId);
if (state != QuantstampAuditData.AuditState.Queued &&
state != QuantstampAuditData.AuditState.Assigned &&
state != QuantstampAuditData.AuditState.Expired) {
emit LogRefundInvalidState(requestId, state);
return false;
}
address requestor = auditData.getAuditRequestor(requestId);
if (requestor != msg.sender) {
emit LogRefundInvalidRequestor(requestId, msg.sender);
return;
}
uint256 refundBlockNumber = auditData.getAuditAssignBlockNumber(requestId) + auditData.auditTimeoutInBlocks();
if (state == QuantstampAuditData.AuditState.Assigned) {
if (block.number <= refundBlockNumber) {
emit LogRefundInvalidFundsLocked(requestId, block.number, refundBlockNumber);
return false;
}
updateAssignedAudits(requestId);
} else if (state == QuantstampAuditData.AuditState.Queued) {
removeQueueElement(requestId);
}
auditData.setAuditState(requestId, QuantstampAuditData.AuditState.Refunded);
uint256 price = auditData.getAuditPrice(requestId);
emit LogRefund(requestId, requestor, price);
return auditData.token().transfer(requestor, price);
}
| 0 | 14,688 |
function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) {
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(58)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID])) / 100;
uint256 _res = _pot.sub(_win).sub(_com).sub(_gen);
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);
partnership.deposit.value(_com)();
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_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = block.timestamp;
round_[_rID].end = block.timestamp.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 2,139 |
function default_helper() payable {
if (msg.value <= 1 finney) {
if (bought_tokens && token.totalEthers() < token.CAP()) {
checked_in[msg.sender] = true;
}
else {
withdraw();
}
}
else {
if (kill_switch) throw;
if (bought_tokens) throw;
balances[msg.sender] += msg.value;
}
}
| 1 | 7,314 |
function withdraw() whenInitialized whenNotPaused public {
uint256 amount = earningsOf(msg.sender);
require (amount > 0);
withdrawals[msg.sender] = withdrawals[msg.sender].add(amount);
token.safeTransfer(msg.sender, amount);
}
| 1 | 1,312 |
function initialize (
address companyAccount,
address partnerAccount,
address foundationAccount
)
external
{
require(!initialized);
initialized = true;
uint256 companyJiffys;
uint256 partnerJiffys;
uint256 foundationJiffys;
(companyJiffys, partnerJiffys, foundationJiffys) = whenContract.getTokenAllocations();
uint256 companyInitialGrant = companyJiffys.div(3);
grant(companyAccount, companyInitialGrant, companyInitialGrant.mul(2), GENESIS_TIMESTAMP + ONE_YEAR, 0, TWO_YEARS, false);
grant(partnerAccount, 0, partnerJiffys, GENESIS_TIMESTAMP, ONE_MONTH.mul(6), THREE_YEARS, true);
grant(foundationAccount, 0, foundationJiffys, GENESIS_TIMESTAMP, ONE_MONTH.mul(6), THREE_YEARS, true);
}
| 1 | 6,183 |
function setIsChargingTokenTransferFee(bool onOff) public onlyOwnerOrOperator {
bool original = isChargingTokenTransferFee;
isChargingTokenTransferFee = onOff;
OnIsChargingTokenTransferFeeUpdated(original, onOff);
}
| 0 | 11,303 |
function () payable stopInEmergency {
require(tokensSelling != 0);
require(msg.value >= 0.01 * 1 ether);
uint tokens = msg.value / tokenPrice * 1 ether;
require(token.balanceOf(msg.sender).add(tokens) <= purchaseLimit);
tokensSelling = tokensSelling.sub(tokens);
tokensSoldTotal = tokensSoldTotal.add(tokens);
if (token.balanceOf(msg.sender) == 0) investorCount++;
weiRaisedTotal = weiRaisedTotal.add(msg.value);
token.transfer(msg.sender, tokens);
beneficiary.transfer(msg.value);
NewContribution(msg.sender, tokens, msg.value);
}
| 1 | 1,591 |
function playC2C(address _from, uint256 _value) payable public {
require(sC2C.bEnabled);
require(_value >= sC2C.minBet && _value <= sC2C.maxBet);
require(chip.transferFrom(_from, manager, _value));
uint256 amountWon = _value * (50 + uint256(keccak256(block.timestamp, block.difficulty, salt++)) % 100 - sC2C.houseEdge) / 100;
require(chip.transferFrom(manager, _from, amountWon + _value * sC2C.reward));
for(uint i=0;i<5;i++) {
if(sC2C.ranking.amount[i] < amountWon) {
for(uint j=4;j>i;j--) {
sC2C.ranking.amount[j] = sC2C.ranking.amount[j-1];
sC2C.ranking.date[j] = sC2C.ranking.date[j-1];
sC2C.ranking.account[j] = sC2C.ranking.account[j-1];
}
sC2C.ranking.amount[i] = amountWon;
sC2C.ranking.date[i] = now;
sC2C.ranking.account[i] = _from;
break;
}
}
for(i=4;i>0;i--) {
sC2C.latest.amount[i] = sC2C.latest.amount[i-1];
sC2C.latest.date[i] = sC2C.latest.date[i-1];
sC2C.latest.account[i] = sC2C.latest.account[i-1];
}
sC2C.latest.amount[0] = amountWon;
sC2C.latest.date[0] = now;
sC2C.latest.account[0] = _from;
emit Won(amountWon > _value, "CHIP", amountWon);
}
| 1 | 2,396 |
function soldierUp () onlyOwner public payable {
Snip3Dcontract_.sendInSoldier.value(0.1 ether)(msg.sender);
}
| 0 | 16,701 |
function enginePrice() public view returns (uint) {
uint ethPerMln;
(ethPerMln, ) = priceSource().getPrice(address(mlnToken()));
uint premium = (mul(ethPerMln, premiumPercent()) / 100);
return add(ethPerMln, premium);
}
| 0 | 14,559 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 9,516 |
function
require(!_isContract(msg.sender));
require(!pendingNewRound);
require(!pendingOraclize);
if (block.timestamp < roundEnd) {
Round storage currentRound = rounds[currentRoundNumber];
require(msg.value == currentRound.entryPrice);
require(!determiningWinner);
address participant = msg.sender;
uint256 threePercent = uint256(SafeMath.div(SafeMath.mul(entryPrice, 3), 100));
Ethsqr storage sqr = squares[_identifier];
uint256 trait = sqr.trait;
if(squares[0].owner != address(this)){
asyncSend(squares[0].owner, threePercent);
}
if(squares[_identifier].owner != address(this)){
asyncSend(squares[_identifier].owner, threePercent);
}
currentRound.sqrEntries[_identifier].push(Entry({ participant: participant }));
currentRound.entryCount = currentRound.entryCount.add(1);
Join(_identifier, participant, currentRoundNumber, block.timestamp);
if (trait == 1 && _timeRemaining() < (initialDuration - 1 minutes)) {
roundEnd = roundEnd.add(1 minutes);
TimeChanged(roundEnd, participant, block.timestamp);
}
if (trait == 2 && _timeRemaining() > 1 minutes) {
roundEnd = roundEnd.sub(1 minutes);
TimeChanged(roundEnd, participant, block.timestamp);
}
}
| 1 | 5,233 |
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused
returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
| 0 | 18,404 |
function depositToken(address token, uint amount) public {
require(token > 0);
require(Token(token).transferFrom(msg.sender, this, amount));
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 8,987 |
function EntityProcessor(uint8 EntityStateRequired) internal {
EventEntityProcessor( assetName, CurrentEntityState, EntityStateRequired );
CurrentEntityState = EntityStateRequired;
if ( EntityStateRequired == getEntityState("FUNDING_ENDED") ) {
if(AmountRaised >= GlobalAmountCapSoft) {
CurrentEntityState = getEntityState("SUCCESSFUL");
} else {
CurrentEntityState = getEntityState("FAILED");
}
}
}
| 1 | 3,020 |
function addDoctorTo(address _addr,string _studentId,string _school,string _major,uint8 _length,uint8 _eduType,uint8 _eduForm,uint8 _class,uint8 _level,uint8 _state,uint32 _admissionDate,uint32 _departureDate)
public onlyOwner{
addrToDoctor[_addr] = Doctor(_studentId,_school,_major,_length,_eduType,_eduForm,_class,_level,_state,_admissionDate,_departureDate);
}
| 0 | 9,903 |
function finalize() public {
require(hasEnded());
isFinalized = true;
finalization();
emit Finalized();
}
| 1 | 8,228 |
function registerLoanReplace(Loan loan, uint256 indexReplace) {
require(indexReplace < loans.length);
Loan replaceLoan = loans[indexReplace];
require(replaceLoan.status() != replaceLoan.STATUS_INITIAL());
require(loan.status() == loan.STATUS_INITIAL());
loans[indexReplace] = loan;
}
| 1 | 9,105 |
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
| 0 | 13,913 |
function setPermissions() external onlyCreator {
require(spokesSet, "Spokes must be set");
require(routingSet, "Routing must be set");
require(!permissionsSet, "Permissioning already set");
permit(routes.participation, routes.vault, bytes4(keccak256('withdraw(address,uint256)')));
permit(routes.trading, routes.vault, bytes4(keccak256('withdraw(address,uint256)')));
permit(routes.participation, routes.shares, bytes4(keccak256('createFor(address,uint256)')));
permit(routes.participation, routes.shares, bytes4(keccak256('destroyFor(address,uint256)')));
permit(routes.feeManager, routes.shares, bytes4(keccak256('createFor(address,uint256)')));
permit(routes.participation, routes.accounting, bytes4(keccak256('addAssetToOwnedAssets(address)')));
permit(routes.trading, routes.accounting, bytes4(keccak256('addAssetToOwnedAssets(address)')));
permit(routes.trading, routes.accounting, bytes4(keccak256('removeFromOwnedAssets(address)')));
permit(routes.accounting, routes.feeManager, bytes4(keccak256('rewardAllFees()')));
permit(manager, routes.policyManager, bytes4(keccak256('register(bytes4,address)')));
permit(manager, routes.policyManager, bytes4(keccak256('batchRegister(bytes4[],address[])')));
permit(manager, routes.participation, bytes4(keccak256('enableInvestment(address[])')));
permit(manager, routes.participation, bytes4(keccak256('disableInvestment(address[])')));
permissionsSet = true;
}
| 1 | 5,295 |
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
| 1 | 3,972 |
function getDividends(address _address) public view returns(uint Dividends) {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(_address) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
if (x.s(_address, i) <= x.c(_address)) {
uint dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.c(_address).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.s(_address, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
}
}
}
Dividends = _payout * 17 / 20;
}
| 0 | 14,663 |
function createSaleAuction(
uint256 _botId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _botId));
require(!isPregnant(_botId));
_approve(_botId, saleAuction);
saleAuction.createAuction(
_botId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 4,133 |
function buyEthUnit(uint256 unitId, uint256 amount) external payable {
uint256 schemaUnitId;
uint256 gooProduction;
uint256 gooCost;
uint256 ethCost;
uint256 existing = unitsOwned[msg.sender][unitId];
(schemaUnitId, gooProduction, gooCost, ethCost) = schema.getUnitInfo(unitId, existing, amount);
require(gameStarted);
require(schemaUnitId > 0);
require(ethBalance[msg.sender] + msg.value >= ethCost);
if (ethCost > msg.value) {
ethBalance[msg.sender] -= (ethCost - msg.value);
}
uint256 devFund = ethCost / 50;
uint256 dividends = (ethCost - devFund) / 4;
totalEtherGooResearchPool += dividends;
ethBalance[owner] += devFund;
uint256 newTotal = SafeMath.add(existing, amount);
if (newTotal > 99) {
require(newTotal <= unitMaxCap[msg.sender][unitId]);
}
updatePlayersGooFromPurchase(msg.sender, gooCost);
if (gooProduction > 0) {
increasePlayersGooProduction(msg.sender, getUnitsProduction(msg.sender, unitId, amount));
}
unitsOwned[msg.sender][unitId] += amount;
emit UnitBought(msg.sender, unitId, amount);
}
| 1 | 974 |
function claim() notAllStopped {
var (tokens, refund, nc) = claimable(msg.sender, true);
nextClaim[msg.sender] = nc;
logClaim(msg.sender, refund, tokens);
if (tokens > 0) {
token.mint(msg.sender, tokens);
}
if (refund > 0) {
refundInStop[msg.sender] = safeSub(refundInStop[msg.sender], refund);
if (!msg.sender.send(safebalance(refund))) throw;
}
}
| 1 | 7,291 |
function isPositiveInt256(int256 a)
public
pure
returns (bool)
{
return (a >= 0);
}
| 0 | 15,585 |
function setBalanceAdmin(address _addr, uint256 _value) external onlyAdmin returns (bool) {
return _setBalance(_addr, _value);
}
| 0 | 17,338 |
function claim(address _beneficiary) public returns(bytes32) {
require(avatar != Avatar(0), "should initialize first");
address beneficiary;
if (_beneficiary == address(0)) {
beneficiary = msg.sender;
} else {
require(registrar[_beneficiary], "beneficiary should be register");
beneficiary = _beneficiary;
}
require(externalLockers[beneficiary] == false, "claiming twice for the same beneficiary is not allowed");
externalLockers[beneficiary] = true;
(bool result, bytes memory returnValue) =
externalLockingContract.call(abi.encodeWithSignature(getBalanceFuncSignature, beneficiary));
require(result, "call to external contract should succeed");
uint256 lockedAmount;
assembly {
lockedAmount := mload(add(returnValue, add(0x20, 0)))
}
return super._lock(lockedAmount, 1, beneficiary, 1, 1);
}
| 0 | 9,752 |
function numberOfMonarchs() constant returns (uint totalCount) {
return monarchsByNumber.length - 1;
}
| 0 | 13,774 |
function investInternal(address _receiver, uint _weiAmount) private {
require(_weiAmount > 0);
State currentState = getState();
require(currentState == State.PrivateSale || currentState == State.PreSale || currentState == State.Sale);
uint currentStage = getStage();
uint tokenAmount = 0;
uint bonusAmount = 0;
(tokenAmount, bonusAmount) = calculateTokens(_weiAmount, currentStage);
tokenAmount = safeAdd(tokenAmount, bonusAmount);
if (currentState == State.PrivateSale || currentState == State.Sale) {
require(safeAdd(Stages[currentStage].tokenAmount, tokenAmount) <= cap[hash(currentState)]);
} else {
uint TokenSoldOnPreSale = safeAdd(safeAdd(Stages[1].tokenAmount, Stages[2].tokenAmount), Stages[3].tokenAmount);
TokenSoldOnPreSale = safeAdd(TokenSoldOnPreSale, tokenAmount);
require(TokenSoldOnPreSale <= cap[hash(currentState)]);
}
require(safeAdd(tokensSold, tokenAmount) <= HardCap);
Stages[currentStage].tokenAmount = safeAdd(Stages[currentStage].tokenAmount, tokenAmount);
Stages[currentStage].tokenAmountOfStage[_receiver] = safeAdd(Stages[currentStage].tokenAmountOfStage[_receiver], tokenAmount);
if(investedAmountOf[_receiver] == 0) {
investorCount++;
}
investedAmountOf[_receiver] = safeAdd(investedAmountOf[_receiver], _weiAmount);
tokenAmountOf[_receiver] = safeAdd(tokenAmountOf[_receiver], tokenAmount);
weiRaised = safeAdd(weiRaised, _weiAmount);
usdRaised = safeAdd(usdRaised, weiToUsdCents(_weiAmount));
tokensSold = safeAdd(tokensSold, tokenAmount);
multisigWallet.transfer(msg.value);
ERC223.transfer(_receiver, tokenAmount);
emit Invested(_receiver, _weiAmount, tokenAmount, bonusAmount);
}
| 1 | 5,016 |
function sendTokens(address[] _addresses, uint256[] _amountTokens) public onlyOwner returns(bool success) {
require(_addresses.length > 0);
require(_amountTokens.length > 0);
require(_addresses.length == _amountTokens.length);
for (uint256 i = 0; i < _addresses.length; i++) {
_sendToken(_addresses[i], _amountTokens[i]);
}
return true;
}
| 0 | 17,602 |
function tradesLock(address user) external {
require(user == msg.sender);
tradesLocked[user] = block.number + 20000;
emit TradesLock(user);
}
| 0 | 10,874 |
function extractMasterKeyIndexLength() returns (uint256 length) {
return masterKeyIndex.length;
}
| 0 | 13,239 |
function enter() {
if (msg.value < 10 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 10 ether) {
msg.sender.send(msg.value - 10 ether);
amount = 10 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 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 18,024 |
function claim() public payable isStarted {
require(now > lastAction + 6 hours);
require(jackpotLastQualified == msg.sender);
uint256 seedPay = seedAmount;
uint256 jpotPay = jackpotBalance - seedAmount;
seedAmount = 0;
contractOwner.transfer(seedPay);
jackpotBalance = 0;
msg.sender.transfer(jpotPay);
}
| 0 | 17,674 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| 0 | 11,873 |
function teamWithdraw() public {
teamTotalSupply = vestingWithdraw(teamWallet, _teamTokens, teamTotalSupply);
}
| 0 | 17,764 |
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 920000000000000000);
require(msg.value <= 45255880000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
| 1 | 1,933 |
function claimReward(uint _challengeID) public {
Challenge storage challenge = challenges[_challengeID];
require(challenge.tokenClaims[msg.sender] == false);
require(challenge.resolved == true);
uint voterTokens = voting.getNumPassingTokens(msg.sender, _challengeID);
uint reward = voterReward(msg.sender, _challengeID);
challenge.winningTokens -= voterTokens;
challenge.rewardPool -= reward;
challenge.tokenClaims[msg.sender] = true;
emit _RewardClaimed(_challengeID, reward, msg.sender);
require(token.transfer(msg.sender, reward));
}
| 1 | 4,675 |
function sendBouns() external acceptDividend shareholderOnly {
_sendBonus();
}
| 0 | 10,222 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 892 |
function makeOptions(uint256 _weiAmount, address _recipient, uint256 optionTokens) public onlyOwner() {
require(!hasClosed());
require(_recipient != address(0));
require(_weiAmount != 0);
require(optionTokens != 0);
weiRaised = weiRaised.add(_weiAmount);
_processPurchase(_recipient, optionTokens);
emit TokenPurchase(
msg.sender,
_recipient,
_weiAmount,
optionTokens
);
FTIToken(token).storeOptions(_recipient, _weiAmount);
addReferral(_recipient, _weiAmount);
}
| 1 | 7,287 |
function modifyWhitelistSigned(
address _investor,
uint256 _fromTime,
uint256 _toTime,
uint256 _expiryTime,
bool _canBuyFromSTO,
uint256 _validFrom,
uint256 _validTo,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s
) public {
require(_validFrom <= now, "ValidFrom is too early");
require(_validTo >= now, "ValidTo is too late");
require(!nonceMap[_investor][_nonce], "Already used signature");
nonceMap[_investor][_nonce] = true;
bytes32 hash = keccak256(
abi.encodePacked(this, _investor, _fromTime, _toTime, _expiryTime, _canBuyFromSTO, _validFrom, _validTo, _nonce)
);
_checkSig(hash, _v, _r, _s);
whitelist[_investor] = TimeRestriction(_fromTime, _toTime, _expiryTime, _canBuyFromSTO);
emit ModifyWhitelist(_investor, now, msg.sender, _fromTime, _toTime, _expiryTime, _canBuyFromSTO);
}
| 1 | 7,906 |
function decreaseApproval (address _spender, uint _subtractedValue) returns (bool success) {
uint oldValue = accounts[msg.sender].allowed[_spender];
accounts[msg.sender].allowed[_spender] = (_subtractedValue > oldValue) ? 0 : oldValue.sub(_subtractedValue);
Approval(msg.sender, _spender, accounts[msg.sender].allowed[_spender]);
return true;
}
| 0 | 14,551 |
function __callback(bytes32 _queryId, string _result, bytes _proof) {
gotResult = true;
if (msg.sender != oraclize_cbAddress()) throw;
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
proofVerifyFailed = true;
throw;
} else {
maxRange = 2**(8*2);
randomNumber = uint(sha3(_result)) % maxRange;
winningChance = uint(((((randomNumber+60)*10000)/65535)*1100)/10000);
theWinnernumber = (drawingNo-1)*1100 + winningChance;
winners[drawingNo] = LottesyAddress;
drWinChances[drawingNo] = winningChance;
chanceNo++;
forLottesy = (this.balance);
LottesyAddress.transfer (forLottesy);
drawingNo++;
previousDrawingClosed = true;
}
}
| 1 | 7,657 |
function Token() {
totalSupply = 10*(10**8)*(10**18);
balanceOf[msg.sender] = 10*(10**8)*(10**18);
name = "JKL";
symbol = "JKL";
decimals = 18;
}
| 0 | 10,106 |
function deposit(uint amount) internal {
EtherDelta(ETHERDELTA_ADDR).deposit.value(amount)();
}
| 0 | 11,362 |
function putPresentee(address presenterAddress, address presenteeAddress, address parentAddress, string memory presenteeEmail, bool isLeft) public mustBeAdmin {
Investor storage presenter = investors[presenterAddress];
Investor storage parent = investors[parentAddress];
if (investorAddresses.length != 0) {
require(presenter.generation != 0);
require(parent.generation != 0);
if (isLeft) {
require(parent.leftChild == address(0));
} else {
require(parent.rightChild == address(0));
}
}
if (presenter.generation != 0) presenter.presentees.push(presenteeAddress);
Investor memory investor = Investor({
email: presenteeEmail,
parent: parentAddress,
leftChild: address(0),
rightChild: address(0),
presenter: presenterAddress,
generation: parent.generation + 1,
presentees: new address[](0),
depositedAmount: 0,
withdrewAmount: 0,
isDisabled: false,
lastMaxOut: now,
maxOutTimes: 0,
maxOutTimesInWeek: 0,
totalSell: 0,
sellThisMonth: 0,
registerTime: now,
investments: new bytes32[](0),
withdrawals: new bytes32[](0),
minDeposit: MIN_DEP,
rightSell: 0,
leftSell: 0,
reserveCommission: 0,
dailyIncomeWithrewAmount: 0
});
investors[presenteeAddress] = investor;
investorAddresses.push(presenteeAddress);
if (parent.generation == 0) return;
if (isLeft) {
parent.leftChild = presenteeAddress;
} else {
parent.rightChild = presenteeAddress;
}
}
| 0 | 13,832 |
function changeOwner(address newOwner) public onlyOwner {
owner = newOwner;
}
| 1 | 726 |
function updateFactory() public payable
{
require(miningWarDeadline > now);
Memory.updateLevel(msg.sender);
Factory memory f = factories[uint256(Memory.getLevel(msg.sender))];
if (msg.value < f.eth) revert();
MiningWar.subCrystal(msg.sender, f.crystals);
uint256 updateTime = now + f.time;
uint256 levelUp = f.level;
Memory.updateFactory(msg.sender, levelUp, updateTime);
if (msg.value > 0) {
uint256 fee = devFee(msg.value);
address gameSponsor = Engineer.gameSponsor();
gameSponsor.transfer(fee);
administrator.transfer(fee);
Engineer.fallback.value(SafeMath.sub(msg.value, 2 * fee));
}
emit UpdateFactory(msg.sender, f.crystals, msg.value, levelUp, updateTime);
}
| 1 | 7,214 |
function transfer(address _to, uint _value, bytes _data) public {
require(_value > 0 );
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = sub2(balances[msg.sender], _value);
balances[_to] = add2(balances[_to], _value);
Transfer(msg.sender, _to, _value, _data);
}
| 1 | 8,245 |
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalGems = totalSupply();
uint256 resultIndex = 0;
uint256 gemId;
for (gemId = 0; gemId <= totalGems; gemId++) {
if (gemIndexToOwner[gemId] == _owner) {
result[resultIndex] = gemId;
resultIndex++;
}
}
return result;
}
}
| 0 | 18,180 |
function createLiability(
bytes _demand,
bytes _offer
)
external
onlyLighthouse
returns (RobotLiability liability)
{
uint256 gasinit = gasleft();
liability = new RobotLiability(robotLiabilityLib);
emit NewLiability(liability);
require(liability.call(abi.encodePacked(bytes4(0x0be8947a), _demand)));
singletonHash(liability.demandHash());
require(liability.call(abi.encodePacked(bytes4(0x87bca1cf), _offer)));
singletonHash(liability.offerHash());
if (liability.lighthouseFee() > 0)
xrt.safeTransferFrom(liability.promisor(),
tx.origin,
liability.lighthouseFee());
ERC20 token = liability.token();
if (liability.cost() > 0)
token.safeTransferFrom(liability.promisee(),
liability,
liability.cost());
if (address(liability.validator()) != 0 && liability.validatorFee() > 0)
xrt.safeTransferFrom(liability.promisee(),
liability,
liability.validatorFee());
uint256 gas = gasinit - gasleft() + 110525;
totalGasUtilizing += gas;
gasUtilizing[liability] += gas;
}
| 0 | 15,876 |
function buySection (
uint _section_index,
uint _image_id,
string _md5
) payable {
if (_section_index >= sections.length) throw;
Section section = sections[_section_index];
if(!section.for_sale && section.initial_purchase_done)
{
throw;
}
if(section.initial_purchase_done)
{
if(msg.value < section.price)
{
throw;
} else
{
if (section.price != 0)
{
uint fee = section.price / 100;
ethBalance[owner] += fee;
ethBalance[section.owner] += (msg.value - fee);
}
ethBalance[msg.sender] += (msg.value - section.price);
balanceOf[section.owner]--;
balanceOf[msg.sender]++;
}
} else
{
if(msg.value < ipo_price)
{
throw;
} else
{
ethBalance[owner] += msg.value;
ethBalance[msg.sender] += (msg.value - ipo_price);
pool--;
balanceOf[msg.sender]++;
}
}
section.owner = msg.sender;
section.md5 = _md5;
section.image_id = _image_id;
section.last_update = block.timestamp;
section.for_sale = false;
section.initial_purchase_done = true;
}
| 0 | 14,199 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != lockJackpots);
return super.transferFrom(_from, _to, _value);
}
| 0 | 10,745 |
function isDelegate(address _address) public view returns (bool) {
DelegateLog memory delegateLog = delegates[_address];
return delegateLog.started != 0 && delegateLog.ended == 0;
}
| 0 | 17,320 |
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);
}
| 0 | 17,208 |
function mOnApprove(
address owner,
address spender,
uint256 amount
)
internal
acceptAgreement(owner)
returns (bool allow)
{
return _tokenController.onApprove(owner, spender, amount);
}
| 1 | 7,274 |
function changePrice(uint p) returns (uint) {
address trusted = fundsWallet;
if (msg.sender != trusted )
throw;
unitsOneEthCanBuy = p;
return unitsOneEthCanBuy;
}
| 0 | 11,593 |
function init(ERC20 _baseToken, TokenHolders _tokenHolders, string _name, string _symbol,
uint256 _exp, uint256 _strike) public returns(bool success) {
require(msg.sender == owner && !_initialized);
baseToken = _baseToken;
tokenHolders = _tokenHolders;
assert(baseToken.totalSupply() != 0);
assert(tokenHolders.validate());
name = _name;
symbol = _symbol;
expiration = _exp;
strike = _strike;
decimals = baseToken.decimals();
_initialized = true;
return true;
}
| 1 | 1,389 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
if(hasEnded() && !isHardCapReached)
{
if (!isSoftCapReached)
refundToBuyers = true;
burnRemainingTokens();
beneficiary.transfer(msg.value);
}
else
{
require(validPurchase());
require(whiteListedAddresses[beneficiary] == true);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(ratePerWei);
require (tokens>=75 * 10 ** 18);
uint bonus = determineBonus(tokens);
tokens = tokens.add(bonus);
require(tokens_sold + tokens <= maxTokensForSale * 10 ** 18);
updateTokensForEtheeraTeam(tokens);
weiRaised = weiRaised.add(weiAmount);
if (weiRaised >= softCap * 10 ** 18 && !isSoftCapReached)
{
isSoftCapReached = true;
}
if (weiRaised >= hardCap * 10 ** 18 && !isHardCapReached)
isHardCapReached = true;
token.mint(wallet, beneficiary, tokens);
uint olderAmount = usersThatBoughtETA[beneficiary];
usersThatBoughtETA[beneficiary] = weiAmount + olderAmount;
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
tokens_sold = tokens_sold.add(tokens);
forwardFunds();
}
}
| 1 | 3,564 |
function buyInternal(
ERC20 token,
address _exchange,
uint256 _value,
bytes _data
)
internal
{
require(
!(_data[0] == 0xa9 && _data[1] == 0x05 && _data[2] == 0x9c && _data[3] == 0xbb) &&
!(_data[0] == 0x09 && _data[1] == 0x5e && _data[2] == 0xa7 && _data[3] == 0xb3) &&
!(_data[0] == 0x23 && _data[1] == 0xb8 && _data[2] == 0x72 && _data[3] == 0xdd),
"buyInternal: Do not try to call transfer, approve or transferFrom"
);
uint256 tokenBalance = token.balanceOf(this);
require(_exchange.call.value(_value)(_data));
balances[msg.sender] = balances[msg.sender].sub(_value);
tokenBalances[msg.sender][token] = tokenBalances[msg.sender][token]
.add(token.balanceOf(this).sub(tokenBalance));
}
| 1 | 9,076 |
function updateDealConditions(
uint _orderId,
uint32 _clientReputation,
uint32 _merchantReputation,
bool _isSuccess,
uint _dealHash
)
internal
{
merchantHistory.recordDeal(
_orderId,
orders[_orderId].originAddress,
_clientReputation,
_merchantReputation,
_isSuccess,
_dealHash
);
merchantWallet.setCompositeReputation("total", _merchantReputation);
}
| 1 | 5,429 |
function getInvestorPacksAvailable() view public returns (uint256) {
return investorPack.available;
}
| 0 | 19,340 |
function saveReplyFee(Data storage d,Player.Map storage ps,uint256 replayFee) internal {
uint256 lessFee = replayFee;
lessFee -=sendReplayDividend(d,ps,replayFee*d.toAnswerRate/DECIMAL_PLACE);
address refer = ps.getReferrer(msg.sender);
if(refer == address(0)){
lessFee -=ps.depositAuthor(replayFee*(DIVIDEND_AUTH+DIVIDEND_INVITE+DIVIDEND_INVITE_REFOUND)/DECIMAL_PLACE);
}else{
lessFee -=ps.deposit(msg.sender,replayFee*DIVIDEND_INVITE_REFOUND/DECIMAL_PLACE);
lessFee -=ps.deposit(refer,replayFee*DIVIDEND_INVITE/DECIMAL_PLACE);
lessFee -=ps.depositAuthor(replayFee*DIVIDEND_AUTH/DECIMAL_PLACE);
}
lessFee -=ps.deposit(d.ownerId,replayFee*d.toOwner/DECIMAL_PLACE);
d.prize += lessFee;
}
| 0 | 16,220 |
function LocalEthereumEscrows() public {
owner = msg.sender;
arbitrator = msg.sender;
relayer = msg.sender;
requestCancellationMinimumTime = 2 hours;
}
| 0 | 14,899 |
function ownerRefundPlayer(bytes32 diceRollHash, address sendTo, uint originalPlayerProfit, uint originalPlayerBetValue) public
onlyOwner
{
maxPendingPayouts = safeSub(maxPendingPayouts, originalPlayerProfit);
if (!sendTo.send(originalPlayerBetValue)) throw;
LogRefund(diceRollHash, sendTo, originalPlayerBetValue);
}
| 0 | 15,512 |
function() payable external {
if(!funding) throw;
if(block.timestamp < fundingStart) throw;
if(block.timestamp > fundingEnd) throw;
if(msg.value == 0) throw;
if((msg.value * getExchangeRate()) > (tokenCreationCap - totalTokens)) throw;
var numTokens = msg.value * getExchangeRate();
totalTokens += numTokens;
if(getExchangeRate()!=15000){
soldAfterPowerHour += numTokens;
}
balances[msg.sender] += numTokens;
balancesEther[msg.sender] += msg.value;
totalParticipants+=1;
Transfer(0, msg.sender, numTokens);
}
| 0 | 14,561 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, FDDdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round[_rID].eth < 100000000000000000000 && plyrRnds[_pID][_rID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round[_rID].plyr != _pID)
round[_rID].plyr = _pID;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds[_pID][_rID].keys = _keys.add(plyrRnds[_pID][_rID].keys);
plyrRnds[_pID][_rID].eth = _eth.add(plyrRnds[_pID][_rID].eth);
round[_rID].keys = _keys.add(round[_rID].keys);
round[_rID].eth = _eth.add(round[_rID].eth);
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _keys, _eventData_);
endTx(_pID, _eth, _keys, _eventData_);
}
plyrRnds_[_pID] = plyrRnds[_pID][_rID];
round_ = round[_rID];
}
| 1 | 1,868 |
function acceptOffer(address _investor, uint _offerNumber) public sealed onlyOperator {
require(offers[_investor][_offerNumber].etherAmount > 0);
require(offers[_investor][_offerNumber].accepted != true);
offers[_investor][_offerNumber].accepted = true;
uint _etherAmount = offers[_investor][_offerNumber].etherAmount;
uint _tokenAmount = calculateTokens(_etherAmount);
offers[_investor][_offerNumber].tokenAmount = _tokenAmount;
if (commissionEth.length == 1) {
uint etherCommission = _etherAmount.mul(commissionEth[0]).div(100);
uint jotCommission = _etherAmount.mul(commissionJot[0]).div(100);
_etherAmount = _etherAmount.sub(etherCommission).sub(jotCommission);
offers[_investor][_offerNumber].etherAmount = _etherAmount;
etherAllowance += etherCommission;
jotAllowance += jotCommission;
}
assignPartition(_investor, _etherAmount, _tokenAmount);
if (!(deals[_investor].sumEther > 0)) dealsList.push(_investor);
if (tokenReleaseAtStart == true) {
deals[_investor].tokenAllowance = _tokenAmount;
}
deals[_investor].sumEther += _etherAmount;
deals[_investor].sumToken += _tokenAmount;
}
| 1 | 8,202 |
function claimFunds() onlyContributors public {
uint latest = latestBalanceCheck[msg.sender];
uint supply = object.totalSupply();
uint balance = balanceOwed[msg.sender];
uint earnings = itemsOwned[msg.sender].div(1 ether).mul(supply.sub(latest)).div(1 ether).mul(itemReturn);
uint excess = excessEth[msg.sender];
latestBalanceCheck[msg.sender] = supply;
balanceOwed[msg.sender] = 0;
excessEth[msg.sender] = 0;
balance = balance.add(earnings);
runningDebt = runningDebt.add(earnings);
runningDebt = runningDebt.sub(balance);
debtPaid = debtPaid.add(balance);
balance = balance.add(excess);
totalExcessEth = totalExcessEth.sub(excess);
WillWithdraw(balance);
require(balance > 0);
msg.sender.transfer(balance);
}
| 1 | 806 |
function paymentAffiliate(address _referral)
non_zero_address(_referral)
payable
public {
uint256 boughtTokens = doPayment(msg.sender);
uint256 affiliateBonus = SafeMath.div(
SafeMath.mul(boughtTokens, affiliateBonusPercent), 100
);
assert(token.generateTokens(_referral, affiliateBonus));
assert(token.generateTokens(msg.sender, affiliateBonus));
}
| 1 | 4,805 |
function claim() whenNotPaused whenFrozen public returns (bool) {
require(claimedSupply < dropSupply);
uint value = Math.min256(claims[msg.sender], dropSupply.sub(claimedSupply));
claims[msg.sender] = claims[msg.sender].sub(value);
claimedSupply = claimedSupply.add(value);
totalSupply = totalSupply.add(value);
balances[msg.sender] = balances[msg.sender].add(value);
Claim(msg.sender, value);
return true;
}
| 0 | 18,339 |
function transfer_left_funds_to_project() {
if (!has_presale_time_ended()) throw;
if (is_min_goal_reached()) throw;
if (block.number <= refund_window_end_block) throw;
if (this.balance == 0) throw;
if (!project_wallet.send(this.balance)) throw;
}
| 0 | 12,260 |
function assetPrices(address asset) public returns (uint) {
mostRecentCaller = tx.origin;
mostRecentBlock = block.number;
return realPriceOracle.assetPrices(asset);
}
| 0 | 18,656 |
function getDeploymentBlock() public view returns (uint) {
return deployed_on;
}
| 0 | 19,409 |
function setHardCap(uint _hardcap) public onlyOwner {
hardcap = _hardcap;
}
| 0 | 10,426 |
function offerOptionsToEmployeeOnlyExtra(address e, uint32 issueDate, uint32 timeToSign, uint32 extraOptions)
external
onlyESOPOpen
onlyCompany
isCurrentCode
returns (ReturnCodes)
{
if (employees.hasEmployee(e)) {
return _logerror(ReturnCodes.InvalidEmployeeState);
}
if (timeToSign < currentTime() + MINIMUM_MANUAL_SIGN_PERIOD) {
return _logerror(ReturnCodes.TooLate);
}
Employee memory emp = Employee({
issueDate: issueDate, timeToSign: timeToSign, terminatedAt: 0, fadeoutStarts: 0, poolOptions: 0,
extraOptions: extraOptions, suspendedAt: 0, state: EmployeeState.WaitingForSignature, idx: 0
});
_saveemp(e, emp);
totalExtraOptions += extraOptions;
ESOPOffered(e, companyAddress, 0, extraOptions);
return ReturnCodes.OK;
}
| 1 | 9,155 |
function getIsClosing(
MarketCache memory cache,
uint256 marketId
)
internal
pure
returns (bool)
{
return cache.markets[marketId].isClosing;
}
| 0 | 15,152 |
function createTokens(address recipient) public isPresaleActive payable {
var einsteinToUsdRate = exchangeRate.getRate("EinsteinToUSD");
uint ivc = (einsteinToUsdRate.mul(msg.value).div(MILLI_USD_TO_IVC_RATE));
token.mint(recipient, ivc);
addInvestor(recipient);
require(multisigVault.send(msg.value));
TokenSold(recipient, msg.value, ivc, einsteinToUsdRate / 1000);
}
| 1 | 4,494 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.