func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function isCrowdsale() public constant returns (bool) {
return true;
} | 1 | 299 |
function BuyBooster() public payable
{
require(msg.value >= nextBoosterPrice);
require(miners[msg.sender].lastUpdateTime != 0);
for(uint i = 0; i < NUMBER_OF_BOOSTERS; ++i)
if(boosterHolders[i] == msg.sender)
revert();
address beneficiary = boosterHolders[boosterIndex];
MinerData storage m = miners[beneficiary];
m.unclaimedPot += nextBoosterPrice * 95 / 100;
BuyHandler((nextBoosterPrice / 20));
nextBoosterPrice += nextBoosterPrice / 20;
UpdateMoney();
UpdateMoneyAt(beneficiary);
boosterHolders[boosterIndex] = msg.sender;
boosterIndex += 1;
if(boosterIndex >= 5)
boosterIndex = 0;
} | 1 | 1,556 |
function balanceOf(address account) public view returns(uint256) {
return _balances[account];
} | 1 | 1,003 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
if (totalSupply > (10**26) && block.timestamp >= 1529474460) {
uint halfP = halfPercent(_value);
burn(_from, halfP);
_value = SafeMath.sub(_value, halfP);
}
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
}
Transfer(_from, _to, _value);
return true;
} | 1 | 382 |
function safeguard() {
if(block.number > (fundingEndBlock + 71000)) {
if (!bitplusAddress.send(this.balance)) throw;
}
} | 1 | 941 |
function transfer(address _to, uint256 _value) public returns (bool success){
if (balances[msg.sender] >= _value
&& _value > 0
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)){
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
} | 1 | 2,227 |
function newGame(uint gameId, bytes8 landKey, uint seedBlock, uint userNum, string content) onlyOwner public returns (uint gameIndex) {
require(indexMap[gameId] == 0);
gameIndex = gameNum++;
indexMap[gameId] = gameIndex;
games[gameIndex] = Game(gameId, landKey, seedBlock, userNum, content);
} | 0 | 4,085 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, PCKdatasets.EventReturns memory _eventData_)
private
returns(PCKdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(admin).call.value(_com)()) {
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
potSwap(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit PCKevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = round_[_rID].pot.add(_p3d / 2);
_eventData_.PCPAmount = _p3d.add(_eventData_.PCPAmount);
}
return(_eventData_);
} | 1 | 761 |
function buyTickets() private {
require(now <= CLOSE_TICKET_SALES);
uint256 msgValue = msg.value;
Player storage player = players[msg.sender];
if (player.ticketsCount == 0) {
playersCount++;
}
uint256 ticketsAmount = msgValue.div(TICKET_PRICE);
if (ticketsAmount > MAX_TICKETS_PER_TX) {
ticketsAmount = MAX_TICKETS_PER_TX;
}
uint256 overPayed = msgValue.sub(ticketsAmount.mul(TICKET_PRICE));
if (overPayed > 0) {
msgValue = msgValue.sub(overPayed);
msg.sender.send(overPayed);
}
player.ticketsPacksBuyed.push(ticketsCount);
ticketsBuys[ticketsCount] = TicketsBuy({
player : msg.sender,
ticketsAmount : ticketsAmount
});
player.ticketsCount = player.ticketsCount.add(ticketsAmount);
ticketsCount = ticketsCount.add(ticketsAmount);
address referrerAddress = bytesToAddress(msg.data);
if (referrerAddress != address(0) && referrerAddress != msg.sender) {
uint256 referralAmount = msgValue.mul(REFERRAL_COMMISSION).div(PERCENTS_DIVIDER);
referrerAddress.send(referralAmount);
}
uint256 marketingAmount = msgValue.mul(MARKETING_COMMISSION).div(PERCENTS_DIVIDER);
MARKETING_ADDRESS.send(marketingAmount);
} | 0 | 3,945 |
function transfer(address _to, uint _value, bytes _data) public {
require(balances[msg.sender] >= _value);
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
require(codeLength == 0);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
} | 0 | 3,320 |
function allowWorkerToContribute(address _woid, address _worker, address _enclaveChallenge) public onlyOwner returns (bool)
{
require(iexecHubInterface.isWoidRegistred(_woid));
require(WorkOrder(_woid).m_status() == IexecLib.WorkOrderStatusEnum.ACTIVE);
IexecLib.Contribution storage contribution = m_contributions[_woid][_worker];
IexecLib.Consensus storage consensus = m_consensus[_woid];
require(now <= consensus.consensusTimeout);
address workerPool;
uint256 workerScore;
(workerPool, workerScore) = iexecHubInterface.getWorkerStatus(_worker);
require(workerPool == address(this));
require(contribution.status == IexecLib.ContributionStatusEnum.UNSET);
contribution.status = IexecLib.ContributionStatusEnum.AUTHORIZED;
contribution.enclaveChallenge = _enclaveChallenge;
emit AllowWorkerToContribute(_woid, _worker, workerScore);
return true;
} | 0 | 3,998 |
function createPipe (
uint256 _termsNumber,
uint256 _allowance,
bytes32 _secretHash
) public {
require(msg.sender == owner);
SalesPipe pipe = new SalesPipe(owner, _termsNumber, smartToken, _secretHash);
address pipeAddress = address(pipe);
smartToken.approve(pipeAddress, _allowance);
indexToPipe[pipeIndex] = pipe;
pipeToIndex[pipeAddress] = pipeIndex;
pipeIndex++;
emit CreateSalesPipe(pipeAddress);
} | 0 | 3,799 |
function isAddressValid(address _address) external view returns (bool);
function isTransferValid(address _from, address _to, uint256 _amount)
external view returns (bool);
}
contract IWithRules {
function ruleLength() public view returns (uint256);
function rule(uint256 _ruleId) public view returns (IRule);
function validateAddress(address _address) public view returns (bool);
function validateTransfer(address _from, address _to, uint256 _amount)
public view returns (bool);
function defineRules(IRule[] _rules) public;
event RulesDefined(uint256 count);
}
contract WithRules is IWithRules, Ownable {
IRule[] internal rules;
constructor(IRule[] _rules) public {
rules = _rules;
} | 0 | 4,686 |
function isOpen() public view returns (bool) {
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
} | 1 | 898 |
function findFloorKeyHour(uint _timestamp, bytes32 _low, bytes32 _high) view private returns (bytes32) {
bytes32 hour = toKey(_timestamp, 1 hours);
if (hour < _low) {
return 0;
}
bytes32 low;
bytes32 high;
if (hour > _high) {
(low, high) = fromValue(state.get(_high));
(low, high) = fromValue(state.get(high));
return state.get(high);
}
while (hour >= _low) {
(low, high) = fromValue(state.get(hour));
if (low != 0) {
bytes32 key = findFloorKeyMinute(_timestamp, low, high);
if (key != 0) {
return key;
}
}
assembly {
hour := sub(hour, 3600)
}
}
return 0;
} | 0 | 4,216 |
function decreaseApproval(address _spender,uint256 _subtractedValue) public returns (bool) {
if(_spender == leaseExchange) {
require(allowed[msg.sender][_spender].sub(_subtractedValue) >= LEMB.getAmountForUserMining(msg.sender));
}
super.decreaseApproval(_spender,_subtractedValue);
} | 0 | 4,352 |
function GetWin(uint _duelID) external {
_duel storage duel = Duels[_duelID];
require(duel.state == State.OnGoing);
require(duel.creator == msg.sender || duel.responder == msg.sender);
require(block.number > duel.blocknumber + 1);
duel.state = State.Closed;
uint duel_fee = 0;
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
if (blockhash(duel.blocknumber) == 0 || (block.number - duel.blocknumber) > 256) {
duel_fee = safePerc(duel.bet, fee);
duel.creator.transfer(safeSub(duel.bet, duel_fee));
duel.responder.transfer(safeSub(duel.bet, duel_fee));
reward[N] = safeAdd(reward[N], safeMul(2, duel_fee));
emit refundDuel(_duelID);
} else {
uint hash = uint(keccak256(abi.encodePacked(blockhash(duel.blocknumber + 1), duel.creator, duel.responder, duel.bet)));
uint duel_bet_common = safeMul(2, duel.bet);
duel_fee = safePerc(duel_bet_common, fee);
uint refFee = 0;
uint sum = safeSub(duel_bet_common, duel_fee);
address winner;
if (hash % 2 == 0) {
duel.creator.transfer(sum);
winner = duel.creator;
emit resultDuel(_duelID, duel.creator, sum);
} else {
duel.responder.transfer(sum);
winner = duel.responder;
emit resultDuel(_duelID, duel.responder, sum);
}
if (RefAddr[winner] != address(0)) {
refFee = refLevel1Fee;
rewardAddr[RefAddr[winner]] = safeAdd(rewardAddr[RefAddr[winner]], safePerc(duel_fee, refLevel1Fee));
if (RefAddr[RefAddr[winner]] != address(0)) {
refFee = safeAdd(refFee, refLevel2Fee);
rewardAddr[RefAddr[RefAddr[winner]]] = safeAdd(rewardAddr[RefAddr[RefAddr[winner]]], safePerc(duel_fee, refLevel2Fee));
}
}
if (duel.refID != 0) {
refFee = safeSub(refGroupFee, refFee);
rewardGroup[RefGroup[duel.refID]] = safeAdd(rewardGroup[RefGroup[duel.refID]], safePerc(duel_fee, refFee));
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, refGroupFee)));
} else {
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, refFee)));
}
}
} | 1 | 1,402 |
function claimPrize(address _tokenAddress, uint16 _tileId) public isNotPaused isNotContractCaller {
ERC721 token = ERC721(_tokenAddress);
Prize[] storage prizeArr = prizes[_tileId];
require(prizeArr.length > 0);
address claimer;
uint blockValue;
uint lastClaimTime;
uint sellPrice;
(claimer, blockValue, lastClaimTime, sellPrice) = bwData.getTile(_tileId);
require(lastClaimTime != 0 && claimer == msg.sender);
for(uint idx = 0; idx < prizeArr.length; ++idx) {
if(prizeArr[idx].startTime.add(prizeArr[idx].hodlPeriod) <= block.timestamp
&& lastClaimTime.add(prizeArr[idx].hodlPeriod) <= block.timestamp) {
uint tokenId = prizeArr[idx].tokenId;
address tokenOwner = token.ownerOf(tokenId);
delete prizeArr[idx];
token.safeTransferFrom(tokenOwner, msg.sender, tokenId);
emit PrizeClaimed(_tokenAddress, tokenId);
}
}
} | 1 | 2,224 |
function finalize() public onlyOwner {
require(hasEnded());
require(!isFinalized);
isFinalized = true;
token.generateTokens(operationAdress, OPERATION_AMOUNT);
token.generateTokens(bountyAdress, BOUNTY_AMOUNT);
token.generateTokens(commonBudgetAdress, COMMON_BUDGET_AMOUNT);
token.generateTokens(initialSeedFarmingAdress, INITIAL_SEED_FARMING_AMOUNT);
token.generateTokens(founderAdress, FOUNDER_AMOUNT);
token.generateTokens(reserveAdress, RESERVE_AMOUNT);
vault.close();
token.enableTransfers(true);
token.changeController(newTokenOwner);
vault.transferOwnership(owner);
} | 1 | 1,877 |
function balanceOf(address _who)public constant returns (uint256 balance) {
require(_who != 0x0);
return balanceOf[_who];
} | 0 | 4,482 |
function payFee()
public
payable
returns (bool)
{
IAccessToken act = IAccessToken(
registry.getContractAddress("AccessToken")
);
require(act.distribute(weiToAct(msg.value)));
return true;
} | 0 | 4,568 |
function revealResult(uint token, bytes32 queryId) internal {
SpinRec storage spin = spinsByQuery[queryId];
require(spin.id != 0);
spin.token = token;
address player = addresses[spin.id];
spinsByAddr[player].token = token;
emit Reveal(token, player, spin.bet, queryId);
uint prizeNumerator = 0;
if (token == 444) {
prizeNumerator = jackpotNumerator;
} else if (token == 333 || token == 222 || token == 111) {
prizeNumerator = winNumerator;
} else if (token%10 == 4 || token/10%10 == 4 || token/100%10 == 4) {
prizeNumerator = giftNumerator;
}
uint balance = address(this).balance;
uint prize = 0;
if (prizeNumerator > 0) {
prize = balance / 100 * prizeNumerator;
if (player.send(prize)) {
if (prizeNumerator == jackpotNumerator) {
emit Jackpot(token, player, now, prize, balance);
} else if (prizeNumerator == winNumerator) {
emit Win(token, player, now, prize, balance);
} else {
emit Gift(token, player, now, prize, balance);
}
owner.transfer(spin.bet / ownerDenominator);
}
}
} | 1 | 1,932 |
function enterDungeon(uint256[4] _tokenIds, uint32 _tryingProgress)
whenNotPaused
public
{
require(_tokenIds[0] == 0 || (_tokenIds[0] != _tokenIds[1] && _tokenIds[0] != _tokenIds[2] && _tokenIds[0] != _tokenIds[3]));
require(_tokenIds[1] == 0 || (_tokenIds[1] != _tokenIds[0] && _tokenIds[1] != _tokenIds[2] && _tokenIds[1] != _tokenIds[3]));
require(_tokenIds[2] == 0 || (_tokenIds[2] != _tokenIds[0] && _tokenIds[2] != _tokenIds[1] && _tokenIds[2] != _tokenIds[3]));
require(_tokenIds[3] == 0 || (_tokenIds[3] != _tokenIds[0] && _tokenIds[3] != _tokenIds[1] && _tokenIds[3] != _tokenIds[2]));
if (requiredProgressOfPreviousDungeon != 0) {
require(progressContract.getProgressOfAddressAndId(msg.sender, previousDungeonId) >= requiredProgressOfPreviousDungeon);
}
require(_tryingProgress > 0);
require(_tryingProgress <= progressContract.getProgressOfAddressAndId(msg.sender, locationId) + 1);
require(addressToPlayRecordDateTime[msg.sender] + coolDungeon <= now);
require(checkOwnershipAndAvailability(msg.sender, _tokenIds));
addressToPlayRecordDateTime[msg.sender] = now;
seed += uint32(now);
PlayRecord memory _playRecord;
_playRecord.initialSeed = seed;
_playRecord.progress = _tryingProgress;
_playRecord.tokenIds[0] = _tokenIds[0];
_playRecord.tokenIds[1] = _tokenIds[1];
_playRecord.tokenIds[2] = _tokenIds[2];
_playRecord.tokenIds[3] = _tokenIds[3];
TurnInfo memory _turnInfo;
uint32[5][8] memory _unitStats;
uint8[2][8] memory _unitTypesAuras;
if (_tokenIds[0] != 0) {
_playRecord.unitClassIds[0] = heroContract.getHeroClassId(_tokenIds[0]);
(_playRecord.unitLevels[0], _turnInfo.originalExps[0], _unitStats[0], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[0]);
(, , , , _unitTypesAuras[0][0], , _unitTypesAuras[0][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[0]);
}
if (_tokenIds[1] != 0) {
_playRecord.unitClassIds[1] = heroContract.getHeroClassId(_tokenIds[1]);
(_playRecord.unitLevels[1], _turnInfo.originalExps[1], _unitStats[1], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[1]);
(, , , , _unitTypesAuras[1][0], , _unitTypesAuras[1][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[1]);
}
if (_tokenIds[2] != 0) {
_playRecord.unitClassIds[2] = heroContract.getHeroClassId(_tokenIds[2]);
(_playRecord.unitLevels[2], _turnInfo.originalExps[2], _unitStats[2], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[2]);
(, , , , _unitTypesAuras[2][0], , _unitTypesAuras[2][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[2]);
}
if (_tokenIds[3] != 0) {
_playRecord.unitClassIds[3] = heroContract.getHeroClassId(_tokenIds[3]);
(_playRecord.unitLevels[3], _turnInfo.originalExps[3], _unitStats[3], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[3]);
(, , , , _unitTypesAuras[3][0], , _unitTypesAuras[3][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[3]);
}
var _enemyCombination = addressToEnemyCombination[msg.sender];
if (_enemyCombination.isPersonalized == false) {
_enemyCombination = initialEnemyCombination;
}
uint32[5][8] memory _tmpEnemyBaseStatsAndIVs;
(, , , , _unitTypesAuras[4][0], , _unitTypesAuras[4][1], _tmpEnemyBaseStatsAndIVs[0], _tmpEnemyBaseStatsAndIVs[4], ) = heroContract.getClassInfo(_enemyCombination.enemySlotClassIds[0]);
(, , , , _unitTypesAuras[5][0], , _unitTypesAuras[5][1], _tmpEnemyBaseStatsAndIVs[1], _tmpEnemyBaseStatsAndIVs[5], ) = heroContract.getClassInfo(_enemyCombination.enemySlotClassIds[1]);
(, , , , _unitTypesAuras[6][0], , _unitTypesAuras[6][1], _tmpEnemyBaseStatsAndIVs[2], _tmpEnemyBaseStatsAndIVs[6], ) = heroContract.getClassInfo(_enemyCombination.enemySlotClassIds[2]);
(, , , , _unitTypesAuras[7][0], , _unitTypesAuras[7][1], _tmpEnemyBaseStatsAndIVs[3], _tmpEnemyBaseStatsAndIVs[7], ) = heroContract.getClassInfo(_enemyCombination.enemySlotClassIds[3]);
_playRecord.unitClassIds[4] = _enemyCombination.enemySlotClassIds[0];
_playRecord.unitClassIds[5] = _enemyCombination.enemySlotClassIds[1];
_playRecord.unitClassIds[6] = _enemyCombination.enemySlotClassIds[2];
_playRecord.unitClassIds[7] = _enemyCombination.enemySlotClassIds[3];
_playRecord.unitLevels[4] = _tryingProgress;
_playRecord.unitLevels[5] = _tryingProgress;
_playRecord.unitLevels[6] = _tryingProgress;
_playRecord.unitLevels[7] = _tryingProgress;
for (uint8 i = 0; i < 5; i ++) {
_unitStats[4][i] = _tmpEnemyBaseStatsAndIVs[0][i] + _playRecord.unitLevels[4] * _tmpEnemyBaseStatsAndIVs[4][i];
_unitStats[5][i] = _tmpEnemyBaseStatsAndIVs[1][i] + _playRecord.unitLevels[5] * _tmpEnemyBaseStatsAndIVs[5][i];
_unitStats[6][i] = _tmpEnemyBaseStatsAndIVs[2][i] + _playRecord.unitLevels[6] * _tmpEnemyBaseStatsAndIVs[6][i];
_unitStats[7][i] = _tmpEnemyBaseStatsAndIVs[3][i] + _playRecord.unitLevels[7] * _tmpEnemyBaseStatsAndIVs[7][i];
}
uint32[8] memory _unitAGLs;
for (i = 0; i < 8; i ++) {
_unitAGLs[i] = _unitStats[i][2];
}
_turnInfo.turnOrder = getOrder(_unitAGLs);
_turnInfo.turnLength = 24;
for (i = 0; i < 24; i ++) {
if (_unitStats[4][4] == 0 && _unitStats[5][4] == 0 && _unitStats[6][4] == 0 && _unitStats[7][4] == 0) {
_turnInfo.turnLength = i;
break;
} else if (_unitStats[0][4] == 0 && _unitStats[1][4] == 0 && _unitStats[2][4] == 0 && _unitStats[3][4] == 0) {
_turnInfo.turnLength = i;
break;
}
var _slotId = _turnInfo.turnOrder[(i % 8)];
if (_slotId < 4 && _tokenIds[_slotId] == 0) {
_turnInfo.defenderList[i] = 127;
} else if (_unitStats[_slotId][4] == 0) {
_turnInfo.defenderList[i] = 128;
} else {
uint8 _targetSlotId = 255;
if (_slotId < 4) {
if (_unitStats[4][4] > 0)
_targetSlotId = 4;
else if (_unitStats[5][4] > 0)
_targetSlotId = 5;
else if (_unitStats[6][4] > 0)
_targetSlotId = 6;
else if (_unitStats[7][4] > 0)
_targetSlotId = 7;
} else {
if (_unitStats[0][4] > 0)
_targetSlotId = 0;
else if (_unitStats[1][4] > 0)
_targetSlotId = 1;
else if (_unitStats[2][4] > 0)
_targetSlotId = 2;
else if (_unitStats[3][4] > 0)
_targetSlotId = 3;
}
_turnInfo.defenderList[i] = _targetSlotId;
uint32 _damage = 10;
if ((_unitStats[_slotId][0] * 150 / 100) > _unitStats[_targetSlotId][1])
_damage = max((_unitStats[_slotId][0] * 150 / 100) - _unitStats[_targetSlotId][1], 10);
else
_damage = 10;
if ((_unitStats[_slotId][3] * 150 / 100) > _unitStats[_targetSlotId][2]) {
if (min(max(((_unitStats[_slotId][3] * 150 / 100) - _unitStats[_targetSlotId][2]), 75), 99) <= random(100, 0))
_damage = _damage * 0;
}
else {
if (75 <= random(100, 0))
_damage = _damage * 0;
}
if (_unitStats[_slotId][3] > _unitStats[_targetSlotId][3]) {
if (min(max((_unitStats[_slotId][3] - _unitStats[_targetSlotId][3]), 5), 75) > random(100, 0))
_damage = _damage * 150 / 100;
}
else {
if (5 > random(100, 0))
_damage = _damage * 150 / 100;
}
if (_unitTypesAuras[_slotId][0] == 0 && _unitTypesAuras[_targetSlotId][0] == 1)
_damage = _damage * 125 / 100;
else if (_unitTypesAuras[_slotId][0] == 1 && _unitTypesAuras[_targetSlotId][0] == 2)
_damage = _damage * 125 / 100;
else if (_unitTypesAuras[_slotId][0] == 2 && _unitTypesAuras[_targetSlotId][0] == 0)
_damage = _damage * 125 / 100;
if (_unitTypesAuras[_slotId][1] == 0 && _unitTypesAuras[_targetSlotId][1] == 1)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 1 && _unitTypesAuras[_targetSlotId][1] == 2)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 2 && _unitTypesAuras[_targetSlotId][1] == 0)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 3 && _unitTypesAuras[_targetSlotId][1] == 4)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 4 && _unitTypesAuras[_targetSlotId][1] == 3)
_damage = _damage * 150 / 100;
if(_unitStats[_targetSlotId][4] > _damage)
_unitStats[_targetSlotId][4] -= _damage;
else
_unitStats[_targetSlotId][4] = 0;
_turnInfo.damageList[i] = _damage;
}
}
if (_tokenIds[0] != 0)
heroContract.deploy(_tokenIds[0], locationId, coolHero);
if (_tokenIds[1] != 0)
heroContract.deploy(_tokenIds[1], locationId, coolHero);
if (_tokenIds[2] != 0)
heroContract.deploy(_tokenIds[2], locationId, coolHero);
if (_tokenIds[3] != 0)
heroContract.deploy(_tokenIds[3], locationId, coolHero);
uint8 _deadEnemies = 0;
if (_unitStats[4][4] == 0)
_deadEnemies ++;
if (_unitStats[5][4] == 0)
_deadEnemies ++;
if (_unitStats[6][4] == 0)
_deadEnemies ++;
if (_unitStats[7][4] == 0)
_deadEnemies ++;
if (_deadEnemies == 4) {
TryDungeon(msg.sender, _tryingProgress, progressContract.getProgressOfAddressAndId(msg.sender, locationId), true);
if (_tryingProgress == progressContract.getProgressOfAddressAndId(msg.sender, locationId) + 1) {
progressContract.incrementProgressOfAddressAndId(msg.sender, locationId);
(_playRecord.expReward, _playRecord.goldReward) = giveReward(_tokenIds, _tryingProgress, _deadEnemies, false, _turnInfo.originalExps);
if (_tryingProgress % 10 == 0) {
cardContract.mint(msg.sender, 1, 3);
}
} else {
(_playRecord.expReward, _playRecord.goldReward) = giveReward(_tokenIds, _tryingProgress, _deadEnemies, true, _turnInfo.originalExps);
}
createNewCombination(msg.sender);
}
else {
TryDungeon(msg.sender, _tryingProgress, progressContract.getProgressOfAddressAndId(msg.sender, locationId), false);
(_playRecord.expReward, _playRecord.goldReward) = giveReward(_tokenIds, _tryingProgress, _deadEnemies, false, _turnInfo.originalExps);
}
addressToPlayRecord[msg.sender] = _playRecord;
if (isTurnDataSaved) {
addressToTurnInfo[msg.sender] = _turnInfo;
}
} | 0 | 3,213 |
function withdraw() onlyOwner {
require(softCapReached);
beneficiary.transfer(weiRaised);
token.transfer(beneficiary, token.balanceOf(this));
crowdsaleFinished = true;
} | 1 | 1,512 |
function finalization() internal {
} | 1 | 1,188 |
function mintToken(address target, uint256 mintedAmount) public onlyOwner {
balanceOf[target] =balanceOf[target].add(mintedAmount);
totalSupply =totalSupply.add(mintedAmount);
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
} | 0 | 3,253 |
function releaseVestedTokens(address _adr) public {
VestingSchedule storage vestingSchedule = vestingMap[_adr];
uint256 _totalTokens = safeAdd(vestingSchedule.principleLockAmount, vestingSchedule.bonusLockAmount);
require(safeSub(_totalTokens, vestingSchedule.amountReleased) > 0);
uint256 amountToRelease = 0;
if (block.timestamp >= vestingSchedule.principleLockPeriod && !vestingSchedule.isPrincipleReleased) {
amountToRelease = safeAdd(amountToRelease,vestingSchedule.principleLockAmount);
vestingSchedule.amountReleased = safeAdd(vestingSchedule.amountReleased, amountToRelease);
vestingSchedule.isPrincipleReleased = true;
}
if (block.timestamp >= vestingSchedule.bonusLockPeriod && !vestingSchedule.isBonusReleased) {
amountToRelease = safeAdd(amountToRelease,vestingSchedule.bonusLockAmount);
vestingSchedule.amountReleased = safeAdd(vestingSchedule.amountReleased, amountToRelease);
vestingSchedule.isBonusReleased = true;
}
require(amountToRelease > 0);
ERC20 token = ERC20(TokenAddress);
token.transfer(_adr, amountToRelease);
totalUnreleasedTokens = safeSub(totalUnreleasedTokens, amountToRelease);
VestedTokensReleased(_adr, amountToRelease);
} | 1 | 2,240 |
function AirDrop (address addr) public {
token = HandToken(addr);
require(token.totalSupply() > 0);
tokenAddress = addr;
} | 0 | 4,157 |
function spitoken () public {
owner = msg.sender;
uint256 devTokens = 1000000000e8;
distr(owner, devTokens);
} | 0 | 4,776 |
function _distributeAuctionTax(uint256 tax, address referrer) private {
_distributeLandholderTax(_totalLandholderTax(tax));
uint256 totalJackpotTax = _jackpotTax(tax).add(_nextPotTax(tax));
nextJackpot = nextJackpot.add(totalJackpotTax);
bool hasReferrer = referrer != address(0);
_sendToTeam(_teamTax(tax, hasReferrer));
asyncSend(referrer, _referrerTax(tax, hasReferrer));
} | 0 | 3,194 |
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
require(block.timestamp > lockups[_from]);
require(block.timestamp > lockups[_to]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
} | 1 | 108 |
function () payable canClaim public{
require(msg.value == 0);
claim();
} | 0 | 4,308 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
} | 0 | 3,960 |
function disableStopping() external onlyManyOwners(sha3(msg.data)) {
stoppable = false;
} | 0 | 2,974 |
function withdraw() notOnPause public {
if (block.timestamp >= x.c(msg.sender) + 10 minutes) {
uint _payout = (x.d(msg.sender).mul(x.getInterest(msg.sender)).div(10000)).mul(block.timestamp.sub(x.c(msg.sender))).div(1 days);
x.updateCheckpoint(msg.sender);
}
if (_payout > 0) {
if (_payout > address(this).balance) {
nextWave();
return;
}
msg.sender.transfer(_payout);
emit LogIncome(msg.sender, _payout, "withdrawn");
}
} | 1 | 430 |
function _buyDiscountTTM(uint256 _value, uint256 _mgrId, address _gameWalletAddr, address _buyer)
private
{
require(_gameWalletAddr != address(0));
if (_mgrId == 1) {
require(nextDiscountTTMTokenId1 <= 50, "This Manager is sold out");
if (block.timestamp <= endDiscountTime) {
require(_value == 0.64 ether);
} else {
require(_value == 0.99 ether);
}
nextDiscountTTMTokenId1 += 1;
ttmToken.safeGiveByContract(nextDiscountTTMTokenId1 - 1, _gameWalletAddr);
emit ManagerSold(_buyer, _gameWalletAddr, 1, nextDiscountTTMTokenId1);
} else if (_mgrId == 6) {
require(nextDiscountTTMTokenId6 <= 390, "This Manager is sold out");
if (block.timestamp <= endDiscountTime) {
require(_value == 0.97 ether);
} else {
require(_value == 1.49 ether);
}
nextDiscountTTMTokenId6 += 1;
ttmToken.safeGiveByContract(nextDiscountTTMTokenId6 - 1, _gameWalletAddr);
emit ManagerSold(_buyer, _gameWalletAddr, 6, nextDiscountTTMTokenId6);
} else {
require(false);
}
} | 1 | 58 |
function awardRafflePrize(address checkWinner, uint256 checkIndex) external {
require(raffleEndTime < block.timestamp);
require(raffleWinner == 0);
require(erc.ownerOf(tokenId) == address(this));
if (!raffleWinningTicketSelected) {
drawRandomWinner();
}
if (checkWinner != 0) {
TicketPurchases storage tickets = ticketsBoughtByPlayer[checkWinner];
if (tickets.numPurchases > 0 && checkIndex < tickets.numPurchases && tickets.raffleId == raffleId) {
TicketPurchase storage checkTicket = tickets.ticketsBought[checkIndex];
if (raffleTicketThatWon >= checkTicket.startId && raffleTicketThatWon <= checkTicket.endId) {
assignRafflePrize(checkWinner);
return;
}
}
}
for (uint256 i = 0; i < rafflePlayers[raffleId].length; i++) {
address player = rafflePlayers[raffleId][i];
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
uint256 endIndex = playersTickets.numPurchases - 1;
if (raffleTicketThatWon >= playersTickets.ticketsBought[0].startId && raffleTicketThatWon <= playersTickets.ticketsBought[endIndex].endId) {
for (uint256 j = 0; j < playersTickets.numPurchases; j++) {
TicketPurchase storage playerTicket = playersTickets.ticketsBought[j];
if (raffleTicketThatWon >= playerTicket.startId && raffleTicketThatWon <= playerTicket.endId) {
assignRafflePrize(player);
return;
}
}
}
}
} | 1 | 76 |
function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
dt.hour = getHour(timestamp);
dt.minute = getMinute(timestamp);
dt.second = getSecond(timestamp);
dt.weekday = getWeekday(timestamp);
} | 1 | 796 |
function redeemTokens(address _player, address _tokenAddress) public returns (bool success) {
require(acceptedToken(_tokenAddress), "Token must be a registered token");
require(block.timestamp >= closeDate, "Game must be closed");
require(gameDone == true, "Can't redeem tokens until results have been uploaded");
IPickFlixToken _token = IPickFlixToken(_tokenAddress);
uint256 _allowedValue = _token.allowance(_player, address(this));
_token.transferFrom(_player, address(this), _allowedValue);
uint256 _transferedTokens = _allowedValue;
uint256 _playerPercentage = percent(_transferedTokens, _token.totalSupply(), 4);
uint256 _playerRewards = movies[_tokenAddress].totalPlayerRewards.mul(_playerPercentage).div(10**4);
sendTo(_player, _playerRewards);
return true;
} | 1 | 368 |
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 | 5,107 |
function getRefund(uint _courseId) public {
require(customers[msg.sender][_courseId].userId > 0);
require(customers[msg.sender][_courseId].refunded == false);
require(customers[msg.sender][_courseId].purchasedAt + (3 hours) > now);
customers[msg.sender][_courseId].refunded = true;
msg.sender.transfer(customers[msg.sender][_courseId].amount);
RefundPayment(_courseId, customers[msg.sender][_courseId].userId, msg.sender);
} | 1 | 785 |
function deposit(bytes32 _listingHash, uint _amount) external {
Listing storage listingHash = listings[_listingHash];
require(listingHash.owner == msg.sender);
require(token.transferFrom(msg.sender, this, _amount));
listingHash.unstakedDeposit += _amount;
_Deposit(_listingHash, _amount, listingHash.unstakedDeposit);
} | 1 | 2,221 |
function RTECrowdsale(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
uint256 _cap,
address _wallet,
address _issueWallet,
RTEToken _token
)
AllowanceCrowdsale(_issueWallet)
TimedCrowdsale(_openingTime, _closingTime)
Crowdsale(_rate, _wallet, _token)
public
{
require(_cap > 0);
cap = _cap;
bonusTokenVault = new RTEBonusTokenVault(_token);
} | 0 | 3,873 |
function unvote(uint _idPoll) public {
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
require(block.number >= p.startBlock && block.timestamp < p.endTime && !p.canceled, "Poll is inactive");
if(p.voters == 0) return;
uint prevVotes = 0;
for(uint8 i = 0; i < p.numBallots; i++){
uint ballotAmount = p.ballots[i][msg.sender];
prevVotes += ballotAmount;
p.ballots[i][msg.sender] = 0;
if(ballotAmount != 0){
p.qvResults[i] -= sqrt(ballotAmount / 1 ether);
p.results[i] -= ballotAmount;
p.votersByBallot[i]--;
}
}
if(prevVotes != 0){
p.voters--;
}
emit Unvote(_idPoll, msg.sender);
} | 1 | 2,167 |
function globalDailySupply() public view returns (uint) {
uint dailySupply = INITIAL_GLOBAL_DAILY_SUPPLY;
uint thisAuction = currentAuction();
if (thisAuction > AUCTION_WHEN_PERCENTAGE_LOGIC_STARTS) {
uint lastAuctionPurchase = whichAuction(lastPurchaseTick);
uint recentAuction = AUCTION_WHEN_PERCENTAGE_LOGIC_STARTS + 1;
if (lastAuctionPurchase > recentAuction) {
recentAuction = lastAuctionPurchase;
}
uint totalAuctions = thisAuction - recentAuction;
if (totalAuctions > 1) {
uint factor = 36525 + ((totalAuctions - 1) * 2);
dailySupply = (globalSupplyAfterPercentageLogic.mul(2).mul(factor)).div(36525 ** 2);
} else {
dailySupply = globalSupplyAfterPercentageLogic.mul(2).div(36525);
}
if (dailySupply < INITIAL_GLOBAL_DAILY_SUPPLY) {
dailySupply = INITIAL_GLOBAL_DAILY_SUPPLY;
}
}
return dailySupply;
} | 1 | 2,197 |
function getTokenDetails(address token) public view returns(address ad,uint required, bool active, uint valid) {
return (acceptedTokens[token].tokenAddress, acceptedTokens[token].requiredAmount,acceptedTokens[token].active, acceptedTokens[token].validUntil);
} | 1 | 1,892 |
function NASDAQ()
public
{
administrators[0x1044d95817689bf0E87B71a13263107D9cBBB930] = true;
ambassadors_[0x41FE3738B503cBaFD01C1Fd8DD66b7fE6Ec11b01] = true;
ambassadors_[0x1044d95817689bf0E87B71a13263107D9cBBB930] = true;
ambassadors_[0x41fe3dD64cc434a4e3bf6aAd566e25c0b9c20964] = true;
} | 0 | 4,498 |
function createVestingContractWithConstantPercent(
address _benificiary,
uint _cliff,
uint _vestingPeriod,
address _tokenAddress,
uint _periodPercent
)
public
onlyOwner
returns (address vestingContract)
{
vestingContract = new TokenVestingWithConstantPercent(
_benificiary,
_cliff,
_vestingPeriod,
_tokenAddress,
_periodPercent
);
investorToVesting[_benificiary] = vestingContract;
emit VestingContractCreated(tx.origin, vestingContract);
} | 0 | 4,869 |
function transfer(address _to) payable {
uint half = msg.value / 2;
uint halfRemain = msg.value - half;
_to.send(half);
_to.send(halfRemain);
} | 0 | 5,123 |
function updateTeam(address _owner, uint32 _teamId, uint8[] _indices, uint32[] _tokenIds) public {
require(msg.sender == contestContractAddress);
require(_owner != address(0));
require(_tokenIds.length <= playersPerTeam);
require(_indices.length <= playersPerTeam);
require(_indices.length == _tokenIds.length);
Team storage _team = teamIdToTeam[_teamId];
require(_owner == _team.owner);
coreContract.batchEscrowToTeamContract(_owner, _tokenIds);
for (uint8 i = 0; i < _indices.length; i++) {
require(_indices[i] <= playersPerTeam);
uint256 _oldTokenId = uint256(_team.playerTokenIds[_indices[i]]);
uint256 _newTokenId = _tokenIds[i];
coreContract.approve(_owner, _oldTokenId);
coreContract.transferFrom(address(this), _owner, _oldTokenId);
_team.playerTokenIds[_indices[i]] = uint32(_newTokenId);
}
emit TeamUpdated(_teamId);
} | 0 | 4,619 |
function balanceOfUnclaimedGoo(address player) internal constant returns (uint256) {
uint256 lastSave = lastGooSaveTime[player];
if (lastSave > 0 && lastSave < block.timestamp) {
return (1000 * (block.timestamp - lastSave)) / 100;
}
return 0;
} | 1 | 121 |
function setupDisbursement(
address vestor,
uint256 tokens,
uint256 timestamp
)
public
onlyOwner
{
require(block.timestamp < timestamp);
disbursements[vestor].push(Disbursement(timestamp, tokens));
LogSetup(vestor, timestamp, tokens);
} | 1 | 2,372 |
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
require(crowdSaleEndTime <= block.timestamp);
return super.increaseApproval(_spender, _addedValue);
} | 1 | 1,961 |
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint modulo = 100;
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if ((uint(entropy) / modulo) % JACKPOT_MODULO == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 10 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
} | 0 | 3,721 |
function BrazilvsCostaRica() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 0 | 4,764 |
function DepositMTU(uint256 NoOfTokens) paused public {
require(block.timestamp > RedeemingTimeLimit);
address tokenAddress = getAddress("unit");
token tokenFunction = token(tokenAddress);
tokenFunction.transferFrom(msg.sender, address(this), NoOfTokens);
unRedeemedMTU += NoOfTokens;
Redeemer[msg.sender] += NoOfTokens;
emit eAllowedMTU(msg.sender, NoOfTokens);
} | 1 | 910 |
function playE2E() payable public {
require(sE2E.bEnabled);
require(msg.value >= sE2E.minBet && msg.value <= sE2E.maxBet);
uint amountWon = msg.value * (50 + uint(keccak256(block.timestamp, block.difficulty, salt++)) % 100 - sE2E.houseEdge) / 100;
require(msg.sender.send(amountWon));
require(chip.transferFrom(manager, msg.sender, msg.value * sE2E.reward));
for(uint i=0;i<5;i++) {
if(sE2E.ranking.amount[i] < amountWon) {
for(uint j=4;j>i;j--) {
sE2E.ranking.amount[j] = sE2E.ranking.amount[j-1];
sE2E.ranking.date[j] = sE2E.ranking.date[j-1];
sE2E.ranking.account[j] = sE2E.ranking.account[j-1];
}
sE2E.ranking.amount[i] = amountWon;
sE2E.ranking.date[i] = now;
sE2E.ranking.account[i] = msg.sender;
break;
}
}
for(i=4;i>0;i--) {
sE2E.latest.amount[i] = sE2E.latest.amount[i-1];
sE2E.latest.date[i] = sE2E.latest.date[i-1];
sE2E.latest.account[i] = sE2E.latest.account[i-1];
}
sE2E.latest.amount[0] = amountWon;
sE2E.latest.date[0] = now;
sE2E.latest.account[0] = msg.sender;
emit Won(amountWon > msg.value, "ETH", amountWon);
} | 1 | 124 |
function collectFeesInEther(uint _amt) onlyowner {
_amt *= 1 ether;
if (_amt > collectedFees) collectAllFees();
if (collectedFees == 0) throw;
creator.send(_amt);
collectedFees -= _amt;
} | 0 | 2,698 |
function admin_set_min_pay(uint256 _min_pay) onlyAdmin{
require(_min_pay >= 0);
min_pay_wei = _min_pay;
} | 1 | 2,164 |
function _transfer(address _from, address _to, uint256 _tokenId) private {
ownershipTokenCount[_to]++;
teamIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete teamIndexToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
} | 0 | 4,877 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
} | 1 | 1,586 |
function claim(address _payout, address _fee) public {
require(buried[msg.sender]);
require(_payout != _fee);
require(msg.sender != _payout);
require(msg.sender != _fee);
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= epoch);
require(balances[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
uint256 previousBalances = balances[msg.sender] + balances[_payout] + balances[_fee];
balances[msg.sender] -= claimAmount;
balances[_payout] += payAmount;
balances[_fee] += feeAmount;
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
Claim(msg.sender, _payout, _fee);
assert(balances[msg.sender] + balances[_payout] + balances[_fee] == previousBalances);
} | 1 | 1,257 |
function getMonthsPassedEndOfSinceIco() onlyWhenIcoParametersAreSet internal view returns (uint8) {
uint256 timePassedSinceIco = now - icoEndDate;
uint8 monthsPassedSinceIco = uint8(timePassedSinceIco / weekLength);
return monthsPassedSinceIco + 1;
} | 0 | 3,750 |
function quickTrade(address tokenFrom, address tokenTo, uint256 input) payable drainBlock {
uint256 inValue;
uint256 tempInValue = safeAdd(tokenToValue(etherContract,msg.value),
tokenToValue(tokenFrom,input));
inValue = valueWithFee(tempInValue);
uint256 outValue = valueToToken(tokenTo,inValue);
assert(verifiedTransferFrom(tokenFrom,msg.sender,input));
if (tokenTo == etherContract){
assert(msg.sender.call.value(outValue)());
} else assert(Token(tokenTo).transfer(msg.sender, outValue));
Trade(tokenFrom, tokenTo, msg.sender, inValue);
} | 0 | 3,793 |
function sendInSoldier(address masternode, uint256 amount) public updateAccount(msg.sender) payable{
uint256 value = msg.value;
require(value >= amount.mul(100 finney));
address sender = msg.sender;
balances[sender]= balances[sender].add(amount);
_totalSupply= _totalSupply.add(amount);
bullets[sender] = bullets[sender].add(amount).add(amount);
for(uint i=0; i< amount; i++)
{
uint256 spot = nextFormation.add(i);
formation[spot] = sender;
}
nextFormation += i;
lastMove[sender] = block.number;
uint256 buyamount = amount.mul( 5 finney);
P3Dcontract_.buy.value(buyamount)(masternode);
if(value > amount.mul(100 finney)){Refundpot += value.sub(amount.mul(100 finney)) ;}
Refundpot += amount.mul(5 finney);
uint256 spasmamount = amount.mul(2 finney);
SPASM_.disburse.value(spasmamount)();
emit newSoldiers(sender, amount, nextFormation);
} | 0 | 3,689 |
function takeAGuess(uint8 _myGuess) public payable live {
require(msg.value == 0.00025 ether);
uint8 winningNumber = uint8(keccak256(now, owner)) % 10;
if (_myGuess == winningNumber) {
msg.sender.transfer((this.balance*9)/10);
owner.transfer(this.balance);
contractIsAlive = false;
}
} | 1 | 1,178 |
function asm_clean(uint s, uint i)
{
assembly{
let seed := calldataload(4)
let iterations := calldataload(36)
let target :=seed
loop:
target := add(target,seed)
pop(call(0,div(target,0x1000000000000000000000000),0,0,0,0,0))
iterations := sub(iterations,1)
jumpi(loop, iterations)
}
} | 0 | 2,955 |
function withdraw() public {
locker storage l = lockers[msg.sender];
require (block.number > l.freedom && l.bal > 0);
uint value = l.bal;
l.bal = 0;
msg.sender.transfer(value);
Released(msg.sender, value);
} | 1 | 2,592 |
function Withdraw(uint256 AmountToWithdraw){
owner.send(AmountToWithdraw);
} | 0 | 3,781 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _invest_return = 0;
_invest_return = distributeInvest(_pID, _eth, _affID);
_p3d = _p3d.add(_invest_return);
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 2,535 |
function payDay() external {
require(block.timestamp >= nextPayDay);
nextPayDay = block.timestamp.sub((block.timestamp - 1538388000).mod(7 days)).add(7 days);
emit LogGift(top[1].addr, top[2].addr, top[3].addr);
for (uint i = 0; i <= 2; i++) {
top[i+1].addr.transfer(2 ether / 2 ** i);
top[i+1] = Leader(0x0, 0);
}
} | 1 | 2,280 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
admin.transfer(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 442 |
function isPositiveInt256(int256 a)
public
pure
returns (bool)
{
return (a >= 0);
} | 0 | 2,873 |
function buy( address recipient ) payable returns(uint){
require( tx.gasprice <= 50000000000 wei );
require( ! haltSale );
require( saleStarted() );
require( ! saleEnded() );
uint weiPayment = eligibleTestAndIncrement( recipient, msg.value );
require( weiPayment > 0 );
if( msg.value > weiPayment ) {
msg.sender.transfer( msg.value.sub( weiPayment ) );
}
sendETHToMultiSig( weiPayment );
raisedWei = raisedWei.add( weiPayment );
uint recievedTokens = weiPayment.mul( 600 );
assert( token.transfer( recipient, recievedTokens ) );
Buy( recipient, recievedTokens, weiPayment );
return weiPayment;
} | 0 | 4,508 |
function pause() external onlyOwner {
fundingPaused = true;
} | 1 | 925 |
function trade(
uint[] _nums,
address[] _addrs,
bytes32[] _rss
) public whenNotPaused {
uint N = _addrs.length - 1;
require(_nums.length == 6*N+4);
require(_rss.length == 2*N+2);
require(_nums[0] == BUY || _nums[0] == SELL);
saveNonce(_nums[1]);
require(now <= _nums[3]);
bytes32 tradeHash = keccak256(
this, msg.sender, uint8(_nums[0]), _addrs[0], _nums[1], _nums[3]
);
bytes32 orderHash;
for (uint i = 0; i < N; i++) {
checkExpiration(i, _nums);
orderHash = verifyOrder(i, _nums, _addrs, _rss);
tradeHash = keccak256(tradeHash, orderHash, _nums[6*i+9]);
tradeOrder(i, _nums, _addrs);
}
checkTradeSignature(tradeHash, _nums, _rss);
sendTradeEvent(_nums, _addrs);
} | 0 | 3,322 |
function () {
uint addedcafe = msg.value / PricePerCafe;
payed += addedcafe;
} | 0 | 4,728 |
function getManySingletons(bytes4[] interfaceIds)
public
constant
returns (address[])
{
address[] memory addresses = new address[](interfaceIds.length);
uint256 idx;
while(idx < interfaceIds.length) {
addresses[idx] = _singletons[interfaceIds[idx]];
idx += 1;
}
return addresses;
} | 0 | 2,630 |
function flop(uint wad) internal {
skr.mint(sub(wad, fog()));
flip(wad);
require(joy() == 0);
} | 0 | 4,968 |
function withdraw_dao_fund(address to, uint amount) public onlyOwner returns(bool success){
require(amount <= redenom_dao_fund);
accounts[to].balance = accounts[to].balance.add(amount);
redenom_dao_fund = redenom_dao_fund.sub(amount);
return true;
} | 1 | 1,411 |
function _finishGame(uint game_id, uint[] memory numbers) private {
require(games[game_id].bet > 0, "Game not found");
Game storage game = games[game_id];
require(!game.finish, "Game over");
require(game.max_players == game.players.length, "The game has free slots");
require(numbers.length == (game.uniq_numbers.length > 1 ? game.uniq_numbers.length - 1 : 1), "Incorect winning numbers");
uint bank = game.bet * game.max_players;
uint bank_use = oraclize_getPrice("random");
uint num_payout = (bank * (100 - commision) / 100) / numbers.length;
for(uint n = 0; n < numbers.length; n++) {
uint num_w = 0;
for(uint j = 0; j < game.numbers.length; j++) {
if(numbers[n] == game.numbers[j]) {
num_w++;
}
}
uint payout = num_payout / num_w;
for(uint p = 0; p < game.players.length; p++) {
if(numbers[n] == game.numbers[p]) {
if(game.players[p].send(payout)) {
bank_use += payout;
}
emit Winner(game_id, game.players[p], p, payout);
if(referers[game.players[p]] != address(0) && referer_commision > 0) {
uint referer_payout = payout * referer_commision / 100;
if(referers[game.players[p]].send(referer_payout)) {
bank_use += referer_payout;
}
emit RefererPayout(game_id, game.players[p], referers[game.players[p]], referer_payout);
}
}
}
}
if(bank > bank_use) {
owner.send(bank - bank_use);
}
game.finish = true;
emit GameOver(game_id, numbers);
} | 0 | 3,778 |
function addDelegate(address _address) public onlyOwner returns (bool) {
DelegateLog storage delegateLog = delegates[_address];
require(delegateLog.started == 0);
delegateLog.started = block.timestamp;
emit AddDelegate(_address);
return true;
} | 1 | 2,031 |
function play(uint256 betPerRoll, uint16 rolls, uint8 rollUnder) public payable {
require(!GAMEPAUSED
&& msg.value > 0
&& betPerRoll >= MINBET
&& rolls > 0
&& rolls <= 1024
&& betPerRoll <= msg.value
&& rollUnder > 1
&& rollUnder < 100
&& (SafeMath.mul(betPerRoll, 100) / (rollUnder - 1)) <= getMaxWin());
if (betPerRoll < MINBET_forORACLIZE) {
bytes32 blockHash = block.blockhash(block.number);
uint8 houseEdgeInThousandthPercents = HOUSEEDGE_inTHOUSANDTHPERCENTS;
uint256 etherAvailable = msg.value;
uint256[] memory logsData = new uint256[](4);
uint256 winnings;
uint16 gamesPlayed;
uint256 hypotheticalWinAmount = SafeMath.mul(SafeMath.mul(betPerRoll, 100), (1000 - houseEdgeInThousandthPercents)) / (rollUnder - 1) / 1000;
while (gamesPlayed < rolls && etherAvailable >= betPerRoll){
if (uint8(uint256(keccak256(blockHash, gamesPlayed)) % 100) + 1 < rollUnder){
winnings = hypotheticalWinAmount;
if (gamesPlayed <= 255){
logsData[0] += uint256(2) ** (255 - gamesPlayed);
}
else if (gamesPlayed <= 511){
logsData[1] += uint256(2) ** (511 - gamesPlayed);
}
else if (gamesPlayed <= 767){
logsData[2] += uint256(2) ** (767 - gamesPlayed);
}
else {
logsData[3] += uint256(2) ** (1023 - gamesPlayed);
}
}
else {
winnings = 1;
}
gamesPlayed++;
etherAvailable = SafeMath.sub(SafeMath.add(etherAvailable, winnings), betPerRoll);
}
GAMESPLAYED += gamesPlayed;
AMOUNTWAGERED = SafeMath.add(AMOUNTWAGERED, SafeMath.mul(betPerRoll, gamesPlayed));
uint256 developersCut = SafeMath.mul(SafeMath.mul(betPerRoll, houseEdgeInThousandthPercents), gamesPlayed) / 5000;
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
EOSBetBankrollInterface(BANKROLLER).receiveEtherFromGameAddress.value(SafeMath.sub(msg.value, developersCut))();
EOSBetBankrollInterface(BANKROLLER).payEtherToWinner(etherAvailable, msg.sender);
emit DiceSmallBet(gamesPlayed, logsData[0], logsData[1], logsData[2], logsData[3]);
}
else {
bytes32 oraclizeQueryId;
EOSBetBankrollInterface(BANKROLLER).payOraclize(oraclize_getPrice('random', INITIALGASFORORACLIZE + (uint256(1005) * rolls)));
oraclizeQueryId = oraclize_newRandomDSQuery(0, 30, INITIALGASFORORACLIZE + (uint256(1005) * rolls));
diceData[oraclizeQueryId] = DiceGameData({
player : msg.sender,
paidOut : false,
start : block.timestamp,
etherReceived : msg.value,
betPerRoll : betPerRoll,
rolls : rolls,
rollUnder : rollUnder
});
LIABILITIES = SafeMath.add(LIABILITIES, msg.value);
emit BuyRolls(oraclizeQueryId);
}
} | 1 | 1,509 |
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
if (minutesCount < 4321) {
uint256 percent = recentinvestment[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
} else {
uint256 percentfinal = recentinvestment[_address].mul(150).div(100);
uint256 balancefinal = percentfinal.sub(withdrawals[_address]);
return balancefinal;
}
} | 1 | 1,227 |
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success) {
require(!SC_locked);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
} | 0 | 4,283 |
function setDistributionMinimum(address _token, uint256 _minimum) public onlyOwner() {
distributionMinimum[_token] = _minimum;
} | 0 | 3,466 |
function decimals() external view returns (uint) {
return decimals;
} | 0 | 3,826 |
function changePrice(uint256 _tokenId, uint64 _priceGwei) external whenNotPaused {
require(tokenContract.ownerOf(_tokenId) == msg.sender);
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
require(order.seller == msg.sender);
require(order.tmSell == 0);
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(_priceGwei >= 1000000 && _priceGwei <= 999000000000);
order.price = _priceGwei;
AuctionPriceChange(lastIndex, msg.sender, _tokenId, _priceGwei);
} | 1 | 2,330 |
function FidentiaXTokenSale() public {
startTimestamp = 1509930000;
endTimestamp = 1512489599;
tier1Timestamp = 1510102799;
tier2Timestamp = 1510361999;
multiSig = 0x90420B8aef42F856a0AFB4FFBfaA57405FB190f3;
token = new FidentiaXToken();
decimals = token.decimals();
oneCoin = 10 ** decimals;
maxTokens = 130 * (10**6) * oneCoin;
tokensForSale = 130 * (10**6) * oneCoin;
} | 0 | 3,574 |
function refund() public {
if(purchasingAllowed){revert();}
if(now >= refundDeadLine ){revert();}
if((totalSupply - totalBonusTokensIssued) >= tokenSaleMin){revert();}
if(msg.sender == ethFoundDeposit){revert();}
uint256 gatVal= balances[msg.sender];
if(gatVal <=0) {revert();}
uint256 ethVal = weirecives[msg.sender];
LogTransaction(msg.sender,ethVal);
msg.sender.transfer(ethVal);
totalContribution -= ethVal;
weirecives[msg.sender] -= ethVal;
} | 1 | 324 |
function delegatedTransfer(bytes _signature, address _to, uint _value, uint _fee, uint _nonce) whenNotPaused public returns (bool) {
require(_to != address(0) && signatures[_signature] == false);
bytes32 hashedTx = hashDelegatedTransfer(_to, _value, _fee, _nonce);
address from = hashedTx.recover(_signature);
require(from != address(0) && _value.add(_fee) <= balances[from]);
balances[from] = balances[from].sub(_value).sub(_fee);
balances[_to] = balances[_to].add(_value);
balances[msg.sender] = balances[msg.sender].add(_fee);
signatures[_signature] = true;
callTokenFallback(_to, from, _value);
emit Transfer(from, _to, _value);
emit Transfer(from, msg.sender, _fee);
emit DelegatedTransfer(from, _to, msg.sender, _value, _fee);
return true;
} | 0 | 4,347 |
function _deliverBonusTokens(address beneficiary)
private
{
require(
_lockedTokens[beneficiary] > 0,
"No tokens to unlock."
);
_lockedTokens[beneficiary] = 0;
require(
ERC20(address(token())).transfer(beneficiary, _lockedTokens[beneficiary]),
"Could not transfer tokens."
);
} | 1 | 2,276 |
function price(uint timeInSeconds) constant returns(uint) {
if (timeInSeconds < startDatetime) return 0;
if (timeInSeconds <= firstStageDatetime) return 15000;
if (timeInSeconds <= secondStageDatetime) return 12000;
if (timeInSeconds <= endDatetime) return 10000;
return 0;
} | 1 | 2,144 |
function craftUrl(uint256[] memory _cryptos, bool _isCoin)
public
view
returns (string memory url)
{
if (_isCoin) url = coinUrl;
else url = cashUrl;
for (uint256 i = 0; i < _cryptos.length; i++) {
uint256 id = _cryptos[i];
for (uint256 j = 0; j < _cryptos.length; j++) {
if (i == j) break;
require(id != _cryptos[j]);
}
require(bytes(cryptoSymbols[id]).length > 0);
url = url.toSlice().concat(cryptoSymbols[id].toSlice());
}
return url;
} | 0 | 4,538 |
function batchVipWithLock(address[] receivers, uint[] tokens, bool freeze) public whenNotPaused onlyAdmin {
for (uint i = 0; i < receivers.length; i++) {
sendTokensWithLock(receivers[i], tokens[i], freeze);
}
} | 0 | 4,179 |
function buy(address buyer) whenNotPaused whenNotFinished public payable {
require(buyer != address(0));
require(msg.value.mul(ETHUSD) >= minimalPriceUSD.mul(decim).div(1000));
uint256 tokens = msg.value.mul(ETHUSD).mul(getBonus(buyer)).mul(tokenPricePerUSD).div(100).div(100);
tokenReward.transfer(buyer, tokens);
uint256 receivedDollars = msg.value.mul(ETHUSD).div(decim);
balanceOfUSD[buyer] = balanceOfUSD[buyer].add(receivedDollars);
balanceOf[buyer] = balanceOf[buyer].add(msg.value);
tokensRaised = tokensRaised.add(tokens);
if (tokensRaised >= tokenHardCap) {
presaleFinished = true;
uint256 tokenBalance = tokenReward.balanceOf(address(this));
tokenReward.burn(tokenBalance);
}
owner.transfer(msg.value);
} | 0 | 4,440 |
function() payable {
if (!purchasingAllowed) { throw; }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
tokensIssued += totalContribution;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier =
((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) +
((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) +
((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) +
((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
}
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
} | 1 | 1,498 |
function getDocumentIdWithName(string _fileName) public view
returns (uint)
{
bytes32 fileNameKeccak256 = keccak256(_fileName);
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (keccak256(doc.fileName)==fileNameKeccak256) {
return i;
}
}
return 0;
} | 1 | 1,502 |
function _checkReinvest(address _to) private {
if(investors[_to].last_payout > 0 && block.timestamp > investors[_to].last_payout + 22 days) {
uint c = (block.timestamp - investors[_to].last_payout) / 22 days;
for(uint i = 0; i < c; i++) {
investors[_to].invested = investors[_to].invested.add(investors[_to].invested.div(100).mul(20));
_reCalcTop(_to);
}
}
} | 1 | 1,006 |
function CareerChainPrivateSale
(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
address _wallet,
uint256[6] _lockupEndTime,
uint256 _firstVestedLockUpAmount,
uint256 _stagedVestedLockUpAmounts,
CareerChainToken _token
)
public
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
{
require(_lockupEndTime[0] >= block.timestamp);
require(_lockupEndTime[1] >= _lockupEndTime[0]);
require(_lockupEndTime[2] >= _lockupEndTime[1]);
require(_lockupEndTime[3] >= _lockupEndTime[2]);
require(_lockupEndTime[4] >= _lockupEndTime[3]);
require(_lockupEndTime[5] >= _lockupEndTime[4]);
lockupEndTime = _lockupEndTime;
firstVestedLockUpAmount = _firstVestedLockUpAmount;
stagedVestedLockUpAmounts = _stagedVestedLockUpAmounts;
} | 1 | 2,380 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.