func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function buyTokens(address beneficiary) public payable validPurchase {
require(beneficiary != address(0));
assert(weiPerUSDinTGE > 0);
uint256 weiAmount = msg.value;
uint256 rate = getRate();
assert(rate > 0);
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
purchases[beneficiary] = weiAmount;
tokensSold = tokensSold.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
} | 1 | 2,589 |
function _removeSale(uint256 _assetId) internal {
delete tokenIdToSale[_assetId];
var cscNFT = CSCNFTFactory(NFTAddress);
uint256 assetType = cscNFT.getAssetIdItemType(_assetId);
bool hasFound = false;
for (uint i = 0; i < assetTypeSalesTokenId[assetType].length; i++) {
if ( assetTypeSalesTokenId[assetType][i] == _assetId) {
hasFound = true;
}
if(hasFound == true) {
if(i+1 < assetTypeSalesTokenId[assetType].length)
assetTypeSalesTokenId[assetType][i] = assetTypeSalesTokenId[assetType][i+1];
else
delete assetTypeSalesTokenId[assetType][i];
}
}
assetTypeSalesTokenId[assetType].length--;
} | 0 | 3,013 |
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns(uint256)
{
Kitty storage matron = kitties[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Kitty storage sire = kitties[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = kittyIndexToOwner[_matronId];
uint256 kittenId = _createKitty(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
delete matron.siringWithId;
pregnantKitties--;
msg.sender.send(autoBirthFee);
return kittenId;
} | 0 | 4,436 |
function editusetaddress(uint aid, string setaddr) public returns(bool){
require(actived == true);
auctionlist storage c = auctionlisting[aid];
putusers storage data = c.aucusers[c.lastid];
require(data.puser == msg.sender);
require(!frozenAccount[msg.sender]);
data.useraddr = setaddr;
return(true);
} | 0 | 4,588 |
function withdraw (address account, address tokenAddr, uint256 index_from, uint256 index_to) external returns (bool) {
require(account != address(0x0));
uint256 release_amount = 0;
for (uint256 i = index_from; i < lockedBalances[account][tokenAddr].length && i < index_to + 1; i++) {
if (lockedBalances[account][tokenAddr][i].balance > 0 &&
lockedBalances[account][tokenAddr][i].releaseTime <= block.timestamp) {
release_amount = release_amount.add(lockedBalances[account][tokenAddr][i].balance);
lockedBalances[account][tokenAddr][i].balance = 0;
}
}
require(release_amount > 0);
if (tokenAddr == 0x0) {
if (!account.send(release_amount)) {
revert();
}
emit Withdraw(account, tokenAddr, release_amount);
return true;
} else {
if (!ERC20Interface(tokenAddr).transfer(account, release_amount)) {
revert();
}
emit Withdraw(account, tokenAddr, release_amount);
return true;
}
} | 1 | 1,071 |
function freeLottery(uint _gid) public{
require(!gamePaused,'Game Pause');
require(freeLottoActive && lotto[_gid].active,'Free Lotto is closed');
require(now - lotto[_gid].lastTime[msg.sender] >= lotto[_gid].freezeTimer,'in the freeze time');
uint chancex=1;
uint winNo = 0;
if(playerCount[msg.sender]>=3){
chancex=2;
}
if(playerCount[msg.sender]>=6){
chancex=3;
}
winNo=uint(keccak256(abi.encodePacked(msg.sender,block.number,block.timestamp, block.difficulty,block.gaslimit))) % (playerCount[msg.sender]>=3?lotto[_gid].prob/chancex:lotto[_gid].prob)+1;
bool result;
if(winNo==7){
result=true;
msg.sender.transfer(lotto[_gid].prize);
}else{
result=false;
if(playerCount[msg.sender]==0 || lotto[_gid].lastTime[msg.sender] <= now -lotto[_gid].freezeTimer - 15*minute){
playerCount[msg.sender]+=1;
}else{
playerCount[msg.sender]=0;
}
}
emit FreeLottery(luid,msg.sender,result?lotto[_gid].prize:0);
luid=luid+1;
lotto[_gid].lastTime[msg.sender]=now;
} | 1 | 2,488 |
function ClearAuth(address target) external
{
require(CanHandleAuth(tx.origin) || CanHandleAuth(msg.sender));
delete auth_list[target];
} | 0 | 2,810 |
function totalTokens() public view returns (uint) {
return token.totalSupply();
} | 0 | 3,814 |
function areTokensBuyable(uint _roundIndex, uint256 _tokens) internal constant returns (bool)
{
uint256 current_time = block.timestamp;
Round storage round = rounds[_roundIndex];
return (
_tokens > 0 &&
round.availableTokens >= _tokens &&
current_time >= round.startTime &&
current_time <= round.endTime
);
} | 1 | 2,177 |
function buyTokens(address beneficiary) public payable whenNotPaused validPurchase {
require(beneficiary != address(0));
assert(weiPerUSDinTGE > 0);
uint256 weiAmount = msg.value;
uint256 rate = getRate();
assert(rate > 0);
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
purchases[beneficiary] = purchases[beneficiary].add(weiAmount);
tokensSold = tokensSold.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
} | 1 | 2,527 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(locked[_from] == 0);
require(balances[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balances[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
} | 1 | 2,104 |
function getFightRaces(uint _fightId) public view returns(uint[]) {
Fight storage f = fights[_fightId];
if (f.startedAt == 0) return;
uint[] memory r = new uint[](f.raceCount);
for(uint i; i < f.raceCount; i++) {
r[i] = f.raceList[i];
}
return r;
} | 0 | 4,654 |
function withdraw() public {
uint _payout = refBonus[msg.sender];
refBonus[msg.sender] = 0;
for (uint i = 0; i <= index[msg.sender]; i++) {
if (checkpoint[msg.sender] < finish[msg.sender][i]) {
if (block.timestamp > finish[msg.sender][i]) {
_payout = _payout.add((deposit[msg.sender][i].mul(getInterest()).div(100)).mul(finish[msg.sender][i].sub(checkpoint[msg.sender])).div(1 days));
} else {
_payout = _payout.add((deposit[msg.sender][i].mul(getInterest()).div(100)).mul(block.timestamp.sub(checkpoint[msg.sender])).div(1 days));
}
}
}
if (_payout > 0) {
checkpoint[msg.sender] = block.timestamp;
msg.sender.transfer(_payout);
emit LogPayment(msg.sender, _payout);
}
} | 1 | 81 |
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _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);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
} | 0 | 4,880 |
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
require(m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data));
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
} | 0 | 3,671 |
function () payable{
if (block.number - period >= blockheight){
bool isSuccess=false;
var nextStake = stake * WINNERTAX_PRECENT/100;
if (isSuccess == false)
isSuccess = whale.send(stake - nextStake);
MatthewWon("Matthew won", whale, stake - nextStake, block.number);
setFacts();
if (mustBeDestroyed) selfdestruct(whale);
return;
}else{
if (msg.value < stake + DELTA) throw;
bool isOtherSuccess = msg.sender.send(stake);
setFacts();
StakeIncreased("stake increased", whale, stake, blockheight);
}
} | 1 | 1,714 |
function withdraw() payable {
if(block.number > 4199999 && iou_purchased[msg.sender] > token.balanceOf(address(this))) {
uint256 eth_to_refund = eth_sent[msg.sender];
if(eth_to_refund == 0 || iou_purchased[msg.sender] == 0) throw;
total_iou_purchased -= iou_purchased[msg.sender];
eth_sent[msg.sender] = 0;
iou_purchased[msg.sender] = 0;
msg.sender.transfer(eth_to_refund);
return;
}
if(token.balanceOf(address(this)) == 0 || iou_purchased[msg.sender] > token.balanceOf(address(this))) throw;
uint256 iou_to_withdraw = iou_purchased[msg.sender];
if(iou_to_withdraw == 0) throw;
iou_purchased[msg.sender] = 0;
eth_sent[msg.sender] = 0;
total_iou_withdrawn += iou_to_withdraw;
token.transfer(msg.sender, iou_to_withdraw);
} | 1 | 1,488 |
function getInfo3(address _address) public view returns(uint Dividends, uint Bonuses) {
uint _payout;
for (uint i = 0; i <= index[_address]; i++) {
if (checkpoint[_address] < finish[_address][i]) {
if (block.timestamp > finish[_address][i]) {
_payout = _payout.add((deposit[_address][i].div(25)).mul(finish[_address][i].sub(checkpoint[_address])).div(1 days));
} else {
_payout = _payout.add((deposit[_address][i].div(25)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days));
}
}
}
Dividends = _payout;
Bonuses = refBonus[_address];
} | 1 | 1,777 |
function buyTokens() public payable onlyWhitelisted {
require(enabled);
require(block.timestamp >= startTimestamp && block.timestamp <= endTimestamp);
require(msg.value >= minValue);
require(buyAmounts[msg.sender] < maxPerAddress);
require(accumulatedAmount.add(accumulatedAmountExternal) < maxTotal);
uint256 buyAmount;
uint256 refundAmount;
(buyAmount, refundAmount) = _calculateAmounts(msg.sender, msg.value);
if (buyAmounts[msg.sender] == 0) {
addresses.push(msg.sender);
}
accumulatedAmount = accumulatedAmount.add(buyAmount);
buyAmounts[msg.sender] = buyAmounts[msg.sender].add(buyAmount);
msg.sender.transfer(refundAmount);
emit BuyTokens(msg.sender, buyAmount, refundAmount, buyAmount.mul(exchangeRate));
} | 1 | 498 |
function blockTokenFunds(address _tokenAddress, uint _amount) external onlyAuthorized {
uint accountedTokensBalance = tokensBalance[_tokenAddress];
require(
_amount <= accountedTokensBalance,
"Tokens mount to block should be less or equal than balance."
);
tokensBalance[_tokenAddress] = accountedTokensBalance.sub(_amount);
blockedTokensBalance[_tokenAddress] = blockedTokensBalance[_tokenAddress].add(_amount);
emit FundsOperation (
address(this),
msg.sender,
_tokenAddress,
_amount,
PaymentType.Erc20,
OperationType.Block
);
} | 0 | 4,523 |
function buyTokens(address beneficiary) public payable {
bool validPurchase = beneficiary != 0x0 && msg.value != 0 && !isBlacklisted[msg.sender];
uint256 currentTokensAmount = availableTokens();
require(isActive() && validPurchase);
investmentsOf[msg.sender] = investmentsOf[msg.sender].add(msg.value);
uint256 boughtTokens;
uint256 refundAmount = 0;
uint256[2] memory tokensAndRefund = calcMultiStage();
boughtTokens = tokensAndRefund[0];
refundAmount = tokensAndRefund[1];
require(boughtTokens <= currentTokensAmount);
totalSold = totalSold.add(boughtTokens);
if(soldOnStage >= stageCap()) {
toNextStage();
}
rewardToken.transfer(beneficiary, boughtTokens);
if (refundAmount > 0)
refundMoney(refundAmount);
withdrawFunds(this.balance);
} | 0 | 2,767 |
function buy (uint256 _auctionId, address _referral) payable public {
NFTToken CNDERC721 = NFTToken(ERC721Contract);
require(auctions[_auctionId].endTime > now);
require(CNDERC721.ownerOf(auctions[_auctionId].monsterId) != address(0));
require(ceil(msg.value) >= ceil(auctions[_auctionId].price + increaseRate));
require(CNDERC721.ownerOf(auctions[_auctionId].monsterId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = CNDERC721.ownerOf(auctions[_auctionId].monsterId);
address newOwner = msg.sender;
uint256 oldPrice = auctions[_auctionId].price;
uint256 price = ceil(msg.value);
setGenes(price,auctions[_auctionId].monsterId);
CNDERC721.transferAuction(oldOwner, newOwner, auctions[_auctionId].monsterId);
auctions[_auctionId].price = ceil(price);
auctions[_auctionId].bidder = msg.sender;
DTT DTTtoken = DTT(dragonTreasureToken);
if(masterToReferral[msg.sender] != address(0) && masterToReferral[msg.sender] != msg.sender){
DTTtoken.approve(masterToReferral[msg.sender], DTTtoken.allowance(this,masterToReferral[msg.sender]) + (price - oldPrice) / 1000000000 * 5);
}else if(_referral != address(0) && _referral != msg.sender){
masterToReferral[msg.sender] = _referral;
DTTtoken.approve(_referral, DTTtoken.allowance(this,_referral) + (price - oldPrice) / 1000000000 * 5);
}
DTTtoken.approve(msg.sender, DTTtoken.allowance(this,msg.sender) + (price - oldPrice) / 1000000000 * 5);
if(oldPrice > 0)
oldOwner.transfer(oldPrice);
Bought(auctions[_auctionId].monsterId, newOwner, price);
Sold(auctions[_auctionId].monsterId, oldOwner, price);
} | 0 | 2,778 |
function transferFrom(address _from, address _to, uint256 _value)public returns (bool success) {
if (balanceOf[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balanceOf[_to] += _value;
balanceOf[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
} | 0 | 3,525 |
function createApp(
string _appName,
uint256 _appPrice,
string _appParams)
external returns (address createdApp)
{
address newApp = appHub.createApp(
_appName,
_appPrice,
_appParams
);
emit CreateApp(tx.origin, newApp, _appName, _appPrice, _appParams);
return newApp;
} | 0 | 4,881 |
function can be called only when _mode==1");
require(_distDay != 0,"you haven't distributed");
require(_fFinish == false, "not finish");
require(_fCancelDist == false, "must not cancel dist");
uint256 daysAfterDist;
uint256 tday = today();
for(uint256 i=0;i<_details.length;i++){
if (_details[i].isFinish == true) {
continue;
}
require(tday!=_details[i].lastTransferDay,"you have applied for todays token");
daysAfterDist = sub(tday,_distDay);
if(daysAfterDist >= _details[i].lockDay){
if(add(_details[i].transferedAmount, _details[i].oneDayTransferAmount) <= _details[i].distAmount){
_erc20token.transfer(
_details[i].founder,
_details[i].oneDayTransferAmount
);
_details[i].transferedAmount = add(_details[i].transferedAmount, _details[i].oneDayTransferAmount);
}
else if(_details[i].transferedAmount < _details[i].distAmount){
_erc20token.transfer(
_details[i].founder,
sub( _details[i].distAmount, _details[i].transferedAmount)
);
_details[i].transferedAmount = _details[i].distAmount;
}
_details[i].lastTransferDay = tday;
}
} | 0 | 4,201 |
function EMGwithdraw(uint256 weiValue) external onlyOwner {
require(block.timestamp > pubEnd);
require(weiValue > 0);
FWDaddrETH.transfer(weiValue);
} | 1 | 2,309 |
function checkPlanBase(bytes32 planBaseId)
external view returns (uint256, uint256, uint32, bool){
PlanBase storage planBase = planBaseIdToPlanBase[planBaseId];
return (
planBase.minimumAmount,
planBase.lockTime,
planBase.lessToHops,
planBase.isOpen
);
} | 1 | 1,610 |
function changeFundOwner(address _newOwner) {
require(_newOwner != 0x0);
fund.transferOwnership(_newOwner);
} | 1 | 2,339 |
function vestedAmount() public view returns (uint256) {
uint256 vested = 0;
for (uint256 i = 0; i < vesting_offsets.length; i = i.add(1)) {
if (block.timestamp > start.add(vesting_offsets[i])) {
vested = vested.add(vesting_amounts[i]);
}
}
return vested;
} | 1 | 2,476 |
function createBitcoinAddressPrefixTask(bytes prefix, uint256 reward, uint256 requestPublicXPoint, uint256 requestPublicYPoint) public isLastestVersion {
require(prefix.length > 5);
require(prefix[0] == "1");
require(prefix[1] != "1");
require(isValidBicoinAddressPrefix(prefix));
require(isValidPublicKey(requestPublicXPoint, requestPublicYPoint));
if (reward > 0) {
token.transferFrom(tx.origin, this, reward);
} else {
reward = token.balanceOf(this) - totalReward;
}
totalReward += reward;
bytes32 data;
assembly {
data := mload(add(prefix, 32))
}
Task memory task = Task({
taskType: TaskType.BITCOIN_ADDRESS_PREFIX,
taskId: nextTaskId,
creator: tx.origin,
reward: reward,
data: data,
dataLength: prefix.length,
requestPublicXPoint: requestPublicXPoint,
requestPublicYPoint: requestPublicYPoint,
answerPrivateKey: 0
});
tasks.push(task);
indexOfTaskId[nextTaskId] = tasks.length;
TaskCreated(nextTaskId);
nextTaskId++;
} | 0 | 4,114 |
function Best_Bank_with_Interest() {
thebank = msg.sender;
minimum_deposit_amount = 250 ether;
deposit_fee = 5 ether;
contract_alive_until_this_block = 3000000;
count_customer_deposits = 0;
term_deposit_end_block[thebank] = contract_alive_until_this_block;
} | 0 | 4,670 |
function buyInternal(address addr) internal
{
if (referrals[addr] != 0)
{
partners[referrals[addr]] += msg.value / 100;
}
uint256 today = getToday();
if (tokenPriceHistory[today] == 0) tokenPriceHistory[today] = currentTokenPriceInDollar;
uint256 amount = msg.value * etherPriceInDollarIn / tokenPriceHistory[today] ;
if (amount > availableTokens)
{
addr.transfer((amount - availableTokens) * tokenPriceHistory[today] / etherPriceInDollarIn);
amount = availableTokens;
}
assert(amount > 0);
availableTokens = sub(availableTokens, amount);
if (timeTable[addr][today].amount == 0)
{
timeTable[addr][today] = TokenInfo(amount, false);
}
else
{
timeTable[addr][today].amount += amount;
}
if (block.timestamp < 1522357200 && bonuses[addr][today] == 0)
{
bonuses[addr][today] = 1;
}
balances[addr] = add(balances[addr], amount);
totalSupply = add(totalSupply, amount);
emit Transfer(0, addr, amount);
} | 1 | 1,022 |
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
onlyWhileOpen
view
{
super._preValidatePurchase(beneficiary, weiAmount);
} | 1 | 2,480 |
function getEventsHistory() constant returns (BuyBackEmitter) {
return address(eventsHistory) != 0x0 ? eventsHistory : BuyBackEmitter(this);
} | 0 | 5,087 |
function _getCurrentPeriod() view internal returns (Period memory _period) {
_period = Period(0, 0, 0);
uint256 len = periods.length;
for (uint256 i = 0; i < len; i++) {
if ((periods[i].startTimestamp <= block.timestamp) && (periods[i].endTimestamp >= block.timestamp)) {
_period = periods[i];
break;
}
}
} | 1 | 2,186 |
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
uint256 productionGain;
if (upgradeClass == 0) {
unitGooProductionIncreases[player][unitId] += upgradeValue;
productionGain = unitsOwned[player][unitId] * upgradeValue * (10 + unitGooProductionMultiplier[player][unitId]);
increasePlayersGooProduction(player, productionGain);
} else if (upgradeClass == 1) {
unitGooProductionMultiplier[player][unitId] += upgradeValue;
productionGain = unitsOwned[player][unitId] * upgradeValue * (schema.unitGooProduction(unitId) + unitGooProductionIncreases[player][unitId]);
increasePlayersGooProduction(player, productionGain);
} else if (upgradeClass == 2) {
unitAttackIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 3) {
unitAttackMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 4) {
unitDefenseIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 5) {
unitDefenseMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 6) {
unitGooStealingIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 7) {
unitGooStealingMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 8) {
unitMaxCap[player][unitId] = upgradeValue;
}
} | 0 | 3,964 |
function injectItemService(AvatarItemService _itemService) external onlyOwner {
itemService = AvatarItemService(_itemService);
ERC721Service = ERC721(_itemService);
} | 0 | 3,337 |
function getWinSlot(uint256 _keyNumber)
public
view
returns(uint256)
{
uint256 _to = slot.length - 1;
uint256 _from = round[curRoundId-1].slotSum + 1;
uint256 _pivot;
uint256 _pivotWTo;
while (_from <= _to) {
_pivot = (_from + _to) / 2;
_pivotWTo = slot[_pivot].wTo;
if (isWinSlot(_pivot, _keyNumber)) return _pivot;
if (_pivotWTo < _keyNumber) {
_from = _pivot + 1;
} else {
_to = _pivot - 1;
}
}
return _pivot;
} | 1 | 2,312 |
function setPauseCutoffTime(uint256 _pauseCutoffTime) onlyOwner public {
require(_pauseCutoffTime >= block.timestamp);
require(pauseCutoffTime == 0);
pauseCutoffTime = _pauseCutoffTime;
} | 1 | 665 |
function upgradeDocs(address _newAddress) onlyAdmin {
UpgDocs newDocs = UpgDocs(_newAddress);
require(newDocs.confirm(storKey));
Storage.changeAddress(storKey,_newAddress);
_newAddress.send(this.balance);
} | 0 | 5,003 |
function claimTokens(address _claimToken) public onlyOwner {
if (hexToken.controller() == address(this)) {
hexToken.claimTokens(_claimToken);
}
if (_claimToken == 0x0) {
owner.transfer(address(this).balance);
return;
}
ERC20Basic claimToken = ERC20Basic(_claimToken);
uint256 balance = claimToken.balanceOf( address(this) );
claimToken.transfer(owner, balance);
emit ClaimedTokens(_claimToken, owner, balance);
} | 0 | 2,867 |
function release() public {
require(block.timestamp >= releaseTime);
for (uint i=0;i<beneficial.length;i++ ){
uint256 amount = token.balanceOf(this);
require(amount > 0);
uint256 count = beneficiary[beneficial[i]];
if (amount>=count){
beneficiary[beneficial[i]] = 0;
token.safeTransfer(beneficial[i], count);
}
}
} | 1 | 1,552 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=currentReceiverIndex; i<queue.length; i++){
Deposit storage dep = queue[i];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[i];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex = i;
} | 0 | 4,442 |
function unlockFunds() public {
require(gameState == state.closed);
require(hasParticipated[msg.sender] == true);
require(hasWithdrawn[msg.sender] == false);
if(fundsTransfered == false){
require(CreditGAMEInterface(creditGameAddress).checkIfLockCanBeRemoved(address(this)) == true);
CreditGAMEInterface(creditGameAddress).removeLock();
fundsTransfered = true;
emit GameUnlocked(block.number);
}
hasWithdrawn[msg.sender] = true;
uint index = participantIndexes[msg.sender];
uint amount = participationAmount[index];
IERC20Token(tokenAddress).transfer(msg.sender, amount);
totalLockedAmount = IERC20Token(tokenAddress).balanceOf(address(this));
if(totalLockedAmount == 0){
gameState = state.claimed;
CreditGAMEInterface(creditGameAddress).cleanUp();
}
} | 0 | 2,770 |
function executeTransaction()
public
onlyActiveUsersAllowed()
transactionMustBePending()
{
Transaction storage transaction = transactions[transactions.length - 1];
require(now > transaction.time_initiated + users[transaction.initiated_by].delay);
transaction.is_executed = true;
transaction.time_finalized = now;
transaction.finalized_by = msg.sender;
require(transaction.destination.call.value(transaction.value)(transaction.data));
} | 1 | 1,017 |
function updatePollDescription(
uint _idPoll,
bytes _description,
uint8 _numBallots)
public
{
require(_idPoll < _polls.length, "Invalid _idPoll");
require(_numBallots <= 100, "Only a max of 100 ballots are allowed");
Poll storage p = _polls[_idPoll];
require(p.startBlock > block.number, "You cannot modify an active poll");
require(p.author == msg.sender || msg.sender == controller, "Only the owner/controller can modify the poll");
p.numBallots = _numBallots;
p.description = _description;
p.author = msg.sender;
} | 1 | 557 |
function approve(address _spender, uint256 _amount) returns (bool success) {
if (!transfersEnabled) throw;
if ((_amount!=0) && (allowed[msg.sender][_spender] !=0)) throw;
if (isContract(controller)) {
if (!Controller(controller).onApprove(msg.sender, _spender, _amount))
throw;
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 | 2,605 |
function revealVote(uint _pollID, uint _voteOption, uint _salt) public {
require(revealPeriodActive(_pollID));
require(pollMap[_pollID].didCommit[msg.sender]);
require(!pollMap[_pollID].didReveal[msg.sender]);
require(keccak256(_voteOption, _salt) == getCommitHash(msg.sender, _pollID));
uint numTokens = getNumTokens(msg.sender, _pollID);
if (_voteOption == 1) {
pollMap[_pollID].votesFor += numTokens;
} else {
pollMap[_pollID].votesAgainst += numTokens;
}
dllMap[msg.sender].remove(_pollID);
pollMap[_pollID].didReveal[msg.sender] = true;
emit _VoteRevealed(_pollID, numTokens, pollMap[_pollID].votesFor, pollMap[_pollID].votesAgainst, _voteOption, msg.sender);
} | 1 | 1,207 |
function invest() {
investors.push(Investor({
addr: msg.sender,
value: msg.value,
leftPayDays: calculateROI(),
lastDay: getDay()
}));
balance += msg.value * 99 / 100;
currentManager.send(msg.value / 100);
Invest(msg.sender, msg.value);
} | 0 | 2,683 |
function SetEthBonus(uint _EthBonus) public onlyOwner {
require(_EthBonus > 0);
EthBonus = _EthBonus;
stakeContractBalance = token.balanceOf(address(this));
indexOfEthSent = 0;
emit EthBonusSet(_EthBonus);
} | 0 | 2,886 |
function releaseVestedTokens(address _adr) changesToVestingFreezed(_adr) {
VestingSchedule storage vestingSchedule = vestingMap[_adr];
require(safeSub(vestingSchedule.amount, vestingSchedule.amountReleased) > 0);
uint totalTime = block.timestamp - vestingSchedule.startAt;
uint totalSteps = totalTime / vestingSchedule.step;
require(vestingSchedule.cliff <= totalSteps);
uint tokensPerStep = vestingSchedule.amount / vestingSchedule.duration;
if(tokensPerStep * vestingSchedule.duration != vestingSchedule.amount) tokensPerStep++;
uint totalReleasableAmount = safeMul(tokensPerStep, totalSteps);
if(totalReleasableAmount > vestingSchedule.amount) totalReleasableAmount = vestingSchedule.amount;
uint amountToRelease = safeSub(totalReleasableAmount, vestingSchedule.amountReleased);
vestingSchedule.amountReleased = safeAdd(vestingSchedule.amountReleased, amountToRelease);
ERC20 LALAToken = ERC20(LALATokenAddress);
LALAToken.transfer(_adr, amountToRelease);
totalUnreleasedTokens = safeSub(totalUnreleasedTokens, amountToRelease);
VestedTokensReleased(_adr, amountToRelease);
} | 1 | 2,377 |
function payOutBounty(address _referrerAddress, address _candidateAddress) public onlyOwner nonReentrant returns(bool){
uint256 amountCandidate = (ERC20(INDToken).balanceOf(this) / 100) * 50;
uint256 amountReferrer = (ERC20(INDToken).balanceOf(this) / 100) * 50;
assert(block.timestamp >= endDate);
assert(ERC20(INDToken).transfer(_candidateAddress, amountCandidate));
assert(ERC20(INDToken).transfer(_referrerAddress, amountReferrer));
return true;
} | 1 | 1,510 |
function redenominate() public onlyAdmin returns(uint current_round){
require(frozen == false);
require(round<9);
_totalSupply = _totalSupply.sub( team_fund%mul[round] ).sub( redenom_dao_fund%mul[round] ).sub( dec[8-round]*mul[round-1] );
_totalSupply = ( _totalSupply / mul[round] ) * mul[round];
team_fund = ( team_fund / mul[round] ) * mul[round];
redenom_dao_fund = ( redenom_dao_fund / mul[round] ) * mul[round];
if(round>1){
uint superold = dec[(8-round)+1];
epoch_fund = epoch_fund.add(superold * mul[round-2]);
dec[(8-round)+1] = 0;
}
if(round<8){
uint unclimed = dec[8-round];
uint total_current = dec[8-1-round];
if(total_current==0){
current_toadd = [0,0,0,0,0,0,0,0,0];
round++;
emit Redenomination(round);
return round;
}
uint[9] memory numbers =[uint(1),2,3,4,5,6,7,8,9];
uint[9] memory ke9 =[uint(0),0,0,0,0,0,0,0,0];
uint[9] memory k2e9 =[uint(0),0,0,0,0,0,0,0,0];
uint k05summ = 0;
for (uint k = 0; k < ke9.length; k++) {
ke9[k] = numbers[k]*1e9/total_current;
if(k<5) k05summ += ke9[k];
}
for (uint k2 = 5; k2 < k2e9.length; k2++) {
k2e9[k2] = uint(ke9[k2])+uint(k05summ)*uint(weight[k2])/uint(100);
}
for (uint n = 5; n < current_toadd.length; n++) {
current_toadd[n] = k2e9[n]*unclimed/10/1e9;
}
}else{
if(round==8){
epoch_fund = epoch_fund.add(dec[0] * 10000000);
dec[0] = 0;
}
}
round++;
emit Redenomination(round);
return round;
} | 1 | 2,015 |
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
msg.sender.transfer(clockList[id].reward);
clockList[id].reward = 0;
waitingTimers--;
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
} | 1 | 2,351 |
function transfer( address _to, uint256 _value )
public
returns (bool success)
{
if( mapLockRulers[msg.sender].length > 0 ){
require (exchangeTimestamp > 0);
uint256 _lockMoney = 0;
uint256 _preMoney = 0;
uint256 _idx = 0;
uint256 _idx2 = 0;
uint256 _rate = 0;
uint256 _hundred = 100;
uint256 _var1 = 0;
uint256 _var2 = 0;
uint256 _var3 = 0;
for( _idx = 0; _idx < mapLockRulers[msg.sender].length; _idx++ ){
if( mapLockRulers[msg.sender][_idx].utype == 0){
for( _idx2 = 0; _idx2 < privateTimes.length -1; _idx2++ ){
if(privateTimes[_idx2]<=block.timestamp && block.timestamp < privateTimes[_idx2+1]){
_rate = privateRates[_idx2];
_var1 = _hundred.sub(_rate);
_var2 = _var1.mul(mapLockRulers[msg.sender][_idx].money);
_var3 = _var2.div(_hundred);
_lockMoney = _lockMoney.add(_var3 );
break;
}else if( block.timestamp > privateTimes[privateTimes.length -1] ){
_lockMoney = _lockMoney.add(0);
break;
}else if(block.timestamp<privateTimes[0]){
_lockMoney = _lockMoney.add(mapLockRulers[msg.sender][_idx].money);
break;
}
}
}
if(mapLockRulers[msg.sender][_idx].utype == 1){
for( _idx2 = 0; _idx2 < airdropTimes.length -1; _idx2++ ){
if(airdropTimes[_idx2] <= block.timestamp && block.timestamp <= airdropTimes[_idx2+1]){
_rate = airdropRates[_idx2];
_var1 = _hundred.sub(_rate);
_var2 = _var1.mul(mapLockRulers[msg.sender][_idx].money);
_var3 = _var2.div(_hundred);
_lockMoney = _lockMoney.add(_var3 );
break;
}else if( block.timestamp > airdropTimes[airdropTimes.length -1] ){
_lockMoney = _lockMoney.add(0);
break;
}else if(block.timestamp < airdropTimes[0]){
_lockMoney = _lockMoney.add(mapLockRulers[msg.sender][_idx].money);
break;
}
}
}
}
_preMoney = _value.add(_lockMoney);
require ( _preMoney <= balances[msg.sender] );
return _transfer(_to, _value);
}else{
return _transfer(_to, _value);
}
} | 1 | 1,684 |
function isEnded (uint256 pid) public view returns(bool) {
if (pid > getCurrentVoting()) {
return false;
} else if (block.timestamp >= proposals[pid].end_time) {
return true;
}
return false;
} | 1 | 245 |
function createBounty(uint256 _bountyId) external payable {
require(
msg.value >= minBounty + bountyFee
);
Bounty storage bounty = bountyAt[_bountyId];
require(bounty.id == 0);
bountyCount++;
bounty.id = _bountyId;
bounty.bounty = msg.value - bountyFee;
bounty.remainingBounty = bounty.bounty;
bountyFeeCount += bountyFee;
bounty.startTime = block.timestamp;
bounty.owner = msg.sender;
BountyStatus('Bounty submitted', bounty.id, msg.sender, msg.value);
} | 1 | 1,163 |
function callMethod(address _contract, bytes _extraData) external payable createOwnContractIfNeeded {
uint gas = gasleft();
Interacting(contracts[msg.sender]).callMethod.value(msg.value)(_contract, _extraData);
mint(gas - gasleft());
} | 0 | 4,194 |
function setCompte_5 ( string newCompte_5 ) public onlyOwner {
Compte_5 = newCompte_5 ;
} | 0 | 3,121 |
function getClaimAmount(address investor) public constant returns (uint) {
if(getState() != State.Distributing) {
throw;
}
return balances[investor].times(tokensBought) / weiRaised;
} | 0 | 3,125 |
function UpdateMoney() private
{
require(miners[msg.sender].lastUpdateTime != 0);
require(block.timestamp >= miners[msg.sender].lastUpdateTime);
MinerData storage m = miners[msg.sender];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(msg.sender);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
} | 1 | 266 |
function requestVotingRights(uint _numTokens) public {
require(token.balanceOf(msg.sender) >= _numTokens);
voteTokenBalance[msg.sender] += _numTokens;
require(token.transferFrom(msg.sender, this, _numTokens));
emit _VotingRightsGranted(_numTokens, msg.sender);
} | 0 | 5,117 |
function cancellScheduledTx(uint256 blocknumber, address from, address to, uint256 value, uint256 gaslimit, uint256 gasprice,
uint256 fee, bytes data, uint256 aionId, bool schedType) external returns(bool) {
if(schedType) require(blocknumber >= block.timestamp+(3 minutes) || blocknumber <= block.timestamp-(5 minutes));
if(!schedType) require(blocknumber > block.number+10 || blocknumber <= block.number-20);
require(scheduledCalls[aionId]==keccak256(abi.encodePacked(blocknumber, from, to, value, gaslimit, gasprice, fee, data, schedType)));
require(msg.sender==from);
AionClient instance = AionClient(clientAccount[msg.sender]);
bool Status = instance.execfunct(from, value+gasprice*gaslimit+fee, 3000, hex"00");
require(Status);
emit CancellScheduledTxEvent(from, value+gasprice*gaslimit+fee, Status, aionId);
delete scheduledCalls[aionId];
return true;
} | 1 | 1,114 |
function sectionForSale(
uint _section_index
) returns (bool) {
if (_section_index >= sections.length) throw;
Section s = sections[_section_index];
if(s.for_sale)
{
if(s.sell_only_to == 0x0) return true;
if(s.sell_only_to == msg.sender) return true;
return false;
}
else
{
return false;
}
} | 1 | 63 |
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = GoalbonanzaBook.getPlayerID(msg.sender);
bytes32 _name = GoalbonanzaBook.getPlayerName(_pID);
uint256 _laff = GoalbonanzaBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
} | 0 | 3,899 |
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback)
public
returns (bool success)
{
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
ERC223Transfer(_from, _to, _amount, _data);
return true;
} | 0 | 4,789 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
{
require (_value < allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
} | 0 | 3,712 |
function cbAddress()
constant
returns (address _cbAddress)
{
if (cbAddresses[tx.origin] != 0)
_cbAddress = tx.origin;
} | 0 | 2,998 |
function depositBulk (uint colorIndex, uint[] to, uint tokens)
external
notZero(tokens)
{
require (colorIndex < coloredTokens.length, "Invalid color index");
require (
msg.sender == coloredTokens[colorIndex].creator,
"Not authorized to deposit this color"
);
lock(2, tokens * to.length);
for(uint i = 0; i < to.length; ++i){
require (to[i] < UID_MAX, "Invalid UID");
require(toy.ownerOf(to[i]) != address(0), "TOY Token does not exist");
coloredTokens[colorIndex].balances[to[i]] += tokens;
emit DepositColor(to[i], colorIndex, tokens);
}
} | 0 | 4,531 |
function GetCourseInfo(string memory CourseUId) public view notEmpty(CourseUId) returns(string memory) {
bytes10 _courseUId=bytes10(stringToBytes32(CourseUId));
course memory _course;
_course = Course[_courseUId];
require(_course.CourseName.length > 0);
uint len = 110;
len += Institute.length + 10 + _course.CourseName.length + 10 + 10 + Instructor[InstructorUIds[_course.InstructorId]].length;
bytes memory courseInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Course":', courseInfo, pointer);
copyBytesNToBytes('{"Issuer":"', courseInfo, pointer);
copyBytesNToBytes(Institute, courseInfo, pointer);
copyBytesNToBytes('","CourseUId":"', courseInfo, pointer);
copyBytesNToBytes(_courseUId, courseInfo, pointer);
copyBytesNToBytes('","CourseName":"', courseInfo, pointer);
copyBytesToBytes(_course.CourseName, courseInfo, pointer);
copyBytesNToBytes('","StartDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.StartDate, courseInfo, pointer);
copyBytesNToBytes('","EndDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.EndDate, courseInfo, pointer);
copyBytesNToBytes('","DurationHours":"', courseInfo, pointer);
copyBytesNToBytes( uintToBytesN(_course.Hours), courseInfo, pointer);
copyBytesNToBytes('"}}', courseInfo, pointer);
return(string(courseInfo));
} | 0 | 3,353 |
function burnToken(uint256 value) public returns (bool success){
require(balanceOf[msg.sender] >= value);
require(total_supply - value <= total_supply);
balanceOf[msg.sender] -= value;
total_supply -= value;
Burn(msg.sender,value);
return true;
} | 0 | 3,875 |
function getDay(uint timestamp) constant returns (uint16) {
return parseTimestamp(timestamp).day;
} | 1 | 1,876 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= balanceOf[_from]);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 | 5,072 |
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
address _customerAddress = msg.sender;
uint8 localDivFee = 200;
lastHour = getHour(block.timestamp);
if (getHour(block.timestamp) == alertTime1 || getHour(block.timestamp) == alertTime2 || getHour(block.timestamp) == alertTime3){
boolAlertStatus = true;
localDivFee = dividendFeeBuyAlert_;
}else{
boolAlertStatus = false;
localDivFee = dividendFeeBuyClear_;
}
if (msg.sender == dev){
localDivFee = 0;
}
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if(myDividends(true) > 0) withdraw();
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, localDivFee),1000);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
Transfer(_customerAddress, _toAddress, _taxedTokens);
checkHalfLife();
return true;
} | 1 | 2,456 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Notes is Token {
using SafeMath for uint256;
uint256 public constant TOTAL_SUPPLY = 2000 * (10**6) * 10**uint256(decimals);
string public constant name = "NOTES";
string public constant symbol = "NOTES";
uint8 public constant decimals = 18;
string public version = "1.0";
address admin;
bool public activated = false;
mapping (address => bool) public activeGroup;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) allowed;
modifier active()
{
require(activated || activeGroup[msg.sender]);
_;
} | 0 | 4,345 |
function summonHero(address _to, uint8 _heroRankToMint)
private
returns (uint256)
{
uint32 _numberOfClasses = heroContract.numberOfHeroClasses();
uint32[] memory _candidates = new uint32[](_numberOfClasses);
uint32 _count = 0;
for (uint32 i = 0; i < _numberOfClasses; i ++) {
if (heroContract.getClassRank(i) == _heroRankToMint && blackList[i] != true) {
_candidates[_count] = i;
_count++;
}
}
require(_count != 0);
return heroContract.mint(_to, _candidates[random(_count, 0)]);
} | 0 | 3,102 |
function ModifyMine(uint256 _Id, bool _state, string _name, uint _tokensupply) onlyOwner
{
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
oldValue = 0;
subValue = 0;
oldTotalSupply = totalSupply;
TokensToModify = 0;
participatingMines[_Id].active = _state;
participatingMines[_Id].name = _name;
participatingMines[_Id].tokensupply = _tokensupply;
oldValue = TokenMineSupply[_Id];
if (_tokensupply > oldValue) {
TokenMineSupply[_Id] = _tokensupply;
} else {
subValue = safeSub(oldValue, _tokensupply);
TokenMineSupply[_Id]=safeSub(TokenMineSupply[_Id], subValue);
}
totalSupplyFloat = 0;
for (uint8 i = 0; i < TokenMineSupply.length; i++)
{
totalSupplyFloat = safeAdd(TokenMineSupply[i], totalSupplyFloat);
}
emit MineUpdated(_Id, _name, _tokensupply, _state);
totalSupply = totalSupplyFloat;
if (totalSupply > oldTotalSupply) {
TokensToModify = safeSub(totalSupply, oldTotalSupply);
addToken(TokensToModify);
}
if (totalSupply < oldTotalSupply) {
TokensToModify = safeSub(oldTotalSupply, totalSupply);
burn(TokensToModify);
}
} | 1 | 2,436 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(TeamUnicorn).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
} | 1 | 1,784 |
function play_game(uint8 player) internal{
require(stop == false);
require(readyTime[msg.sender] < block.timestamp);
require(player <= 2);
require(sent_times <= sent_limit);
random_source += 1;
uint8 comp=uint8(uint(keccak256(random_source, block.difficulty, block.timestamp))%3);
uint8 result = compare(player, comp);
if (result == 2){
sent_times +=1 ;
require(ERC20Basic(tokenAddress_GIC).transfer(msg.sender, airdrop_GIC));
(uint _player_amount,uint addressA_amount, uint addressB_amount)
= Arina_amount();
require(ERC20Basic(tokenAddress_Arina).transfer(msg.sender, _player_amount));
require(ERC20Basic(tokenAddress_Arina).transfer(address_A , addressA_amount));
require(ERC20Basic(tokenAddress_Arina).transfer(address_B, addressB_amount));
}
else if(result == 1){
}
else if(result == 0){
readyTime[msg.sender] = block.timestamp + cooldown;
}
else revert();
uint bal = ERC20Basic(tokenAddress_GIC).balanceOf(this) + ERC20Basic(tokenAddress_Arina).balanceOf(this);
uint24 random_player = uint24(keccak256(msg.sender, now, random_source))%Probability;
uint24 random_lottery = uint24(keccak256(random_source, block.difficulty, bal))%Probability;
emit Play_game(msg.sender, player, comp, result);
emit Random(msg.sender, random_player, random_lottery);
if (random_player == random_lottery){
uint8 _level = level_judgment(msg.sender);
uint _eth = eth_amount_judgment(_level);
if (address(this).balance >= _eth){
msg.sender.transfer(_eth);
}
else{
msg.sender.transfer(address(this).balance);
}
}
} | 1 | 1,237 |
function claim(
address _arbitrator,
uint256 _transactionId
) public {
Lock memory lock = escrows[_arbitrator][_transactionId];
require(lock.sender == msg.sender);
require(lock.paid);
require(lock.expiration < block.timestamp);
require(lock.expiration != 0);
delete escrows[_arbitrator][_transactionId];
token.transfer(msg.sender, lock.value.add(lock.fee));
Released(
_arbitrator,
msg.sender,
_transactionId
);
} | 1 | 103 |
function refund(uint amount)
public {
if (total[msg.sender] >= amount && amount > 0)
{
if (now >= refundDate && isClosed==false)
{
msg.sender.transfer(amount);
}
}
} | 1 | 1,873 |
function offerStarForSaleToAddress(uint starIndex, uint minSalePriceInWei, address toAddress) {
if (starIndexToAddress[starIndex] != msg.sender) throw;
starsOfferedForSale[starIndex] = Offer(true, starIndex, msg.sender, minSalePriceInWei, toAddress);
StarOffered(starIndex, minSalePriceInWei, msg.sender, toAddress);
} | 0 | 3,362 |
function collectBalance() onlyowner {
balance += msg.value;
if (balance == 0 && now > timeout) return;
owner.send(balance);
balance = 0;
} | 0 | 4,271 |
function registerUser(
address _owner,
bytes32 _label,
address _account,
bytes32 _pubkeyA,
bytes32 _pubkeyB
)
internal
returns(bytes32 namehash)
{
require(state == RegistrarState.Active, "Registry unavailable.");
namehash = keccak256(abi.encodePacked(ensNode, _label));
require(ensRegistry.owner(namehash) == address(0), "ENS node already owned.");
require(accounts[_label].creationTime == 0, "Username already registered.");
accounts[_label] = Account(price, block.timestamp, _owner);
if(price > 0) {
require(token.allowance(_owner, address(this)) >= price, "Unallowed to spend.");
require(
token.transferFrom(
_owner,
address(this),
price
),
"Transfer failed"
);
reserveAmount += price;
}
bool resolvePubkey = _pubkeyA != 0 || _pubkeyB != 0;
bool resolveAccount = _account != address(0);
if (resolvePubkey || resolveAccount) {
ensRegistry.setSubnodeOwner(ensNode, _label, address(this));
ensRegistry.setResolver(namehash, resolver);
if (resolveAccount) {
resolver.setAddr(namehash, _account);
}
if (resolvePubkey) {
resolver.setPubkey(namehash, _pubkeyA, _pubkeyB);
}
ensRegistry.setOwner(namehash, _owner);
} else {
ensRegistry.setSubnodeOwner(ensNode, _label, _owner);
}
emit UsernameOwner(namehash, _owner);
} | 1 | 272 |
function setParams(
uint256[] _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime,
uint8[] _timeMode_bonusMode,
uint256[] _bonusLevels,
uint256[] _bonusRates
)
public
onlyOwner
atStage(Stage.Init)
{
assert(fundingGoal == 0);
fundingThreshold = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[0];
fundingGoal = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[1];
tokenPrice = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[2];
timeMode = TimeMode(_timeMode_bonusMode[0]);
startTime = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[3];
finishTime = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[4];
bonusMode = BonusMode(_timeMode_bonusMode[1]);
bonusLevels = _bonusLevels;
bonusRates = _bonusRates;
require(fundingThreshold > 0);
require(fundingThreshold <= fundingGoal);
require(startTime < finishTime);
require((timeMode == TimeMode.Block ? block.number : block.timestamp) < startTime);
require(bonusLevels.length == bonusRates.length);
} | 1 | 508 |
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
} | 0 | 4,031 |
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
if (to == address(0)) {
knc.transfer(msg.sender, tokens);
omg.transfer(msg.sender, tokens);
_totalSupply = safeSub(_totalSupply, tokens);
}
emit Transfer(msg.sender, to, tokens);
return true;
} | 0 | 5,135 |
function setPreFundingtokens(uint256 _preFundingtokens) public stopIfHalted onlyOwner {
preFundingtokens = _preFundingtokens;
} | 0 | 4,180 |
function() payable public {
require(msg.value > 0);
require(purchasingAllowed);
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * buyTokenPerEther);
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;
balanceOf[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
} | 1 | 865 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
} | 0 | 2,643 |
function mine(uint256 nonce) whenNotPaused returns (bool success) {
require(checkMine(nonce));
Mine(msg.sender, blockReward, uint40(block.timestamp) - uint40(lastMinedOn));
balances[msg.sender] += blockReward;
blockNumber += 1;
totalSupply += blockReward;
updateRandomness();
var mul = (block.timestamp - lastMinedOn);
if (mul > (60*2.5*2)) {
mul = 60*2.5*2;
}
if (mul < (60*2.5/2)) {
mul = 60*2.5/2;
}
target *= mul;
target /= (60*2.5);
if (target > powLimit) {
target = powLimit;
}
lastMinedOn = uint40(block.timestamp);
if (blockNumber % halvingInterval == 0) {
blockReward /= 2;
RewardHalved();
}
return true;
} | 1 | 908 |
function ProLife () {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
allowedAddresses[owner] = true;
} | 0 | 2,859 |
function() public payable {
uint256 _amountWei = msg.value;
address _buyer = msg.sender;
uint valueUSD = weiToUSD(_amountWei);
require(now <= endTime, 'endtime');
require(inversors[_buyer] != false, 'No invest');
require(valueUSD >= minPaymentUSD, 'Min in USD not allowed');
emit ReceiveEthEvent(_buyer, _amountWei);
uint tokensE18SinBono = weiToTokens(msg.value);
uint tokensE18Bono = weiToTokensBono(msg.value);
emit conversionETHToTMSYEvent(_buyer, msg.value, tokensE18SinBono, tokensE18Bono);
uint tokensE18 = tokensE18SinBono.add(tokensE18Bono);
require(token.sell(_buyer, tokensE18SinBono), "Falla la venta");
if(tokensE18Bono > 0)
assert(token.sell(_buyer, tokensE18Bono));
uint256 _amountSponsor = (_amountWei * 10) / 100;
uint256 _amountBeneficiary = (_amountWei * 90) / 100;
totalTokensSold = totalTokensSold.add(tokensE18);
totalWeiReceived = totalWeiReceived.add(_amountWei);
buyerToSentWei[_buyer] = buyerToSentWei[_buyer].add(_amountWei);
if(!isSoftCapComplete) {
uint256 totalBalanceUSD = weiToUSD(balance);
if(totalBalanceUSD >= minCapUSD) {
softCapCompleted();
}
}
address sponsor = inversorToSponsor[_buyer];
sponsorToComisionList.push(sponsor);
if(validateKYC[_buyer]) {
balanceComision = balanceComision.add(_amountSponsor);
sponsorToComision[sponsor] = sponsorToComision[sponsor].add(_amountSponsor);
} else {
balanceComisionHold = balanceComisionHold.add(_amountSponsor);
sponsorToComisionHold[sponsor] = sponsorToComisionHold[sponsor].add(_amountSponsor);
sponsorToComisionFromInversor[_buyer] = sponsorToComisionFromInversor[_buyer].add(_amountSponsor);
}
payComisionSponsor(sponsor);
balance = balance.add(_amountBeneficiary);
} | 0 | 3,105 |
function safeWithdrawal() afterDeadline
{
if (!fundingGoalReached)
{
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0)
{
if (msg.sender.send(amount))
{
FundTransfer(msg.sender, amount, false);
}
else
{
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender)
{
if (beneficiary.send(amountRaised))
{
FundTransfer(beneficiary, amountRaised, false);
}
else
{
fundingGoalReached = false;
}
}
} | 1 | 1,303 |
function buyTokens(address beneficiary) public payable nonZeroAddress(beneficiary) {
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokenPrice = fiat_contract.USD(0);
if(startTime.add(15 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(200).div(10 ** 8);
} else if(startTime.add(45 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(300).div(10 ** 8);
} else if(startTime.add(52 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(330).div(10 ** 8);
} else if(startTime.add(59 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(360).div(10 ** 8);
} else if(startTime.add(66 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(400).div(10 ** 8);
} else {
tokenPrice = tokenPrice.mul(150).div(10 ** 8);
}
uint256 call_units = weiAmount.div(tokenPrice).mul(10 ** 10);
uint256 callg_units = call_units.mul(200);
forwardFunds();
weiRaised = weiRaised.add(weiAmount);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, call_units);
require(token_call.transfer(beneficiary, call_units));
require(token_callg.transfer(beneficiary, callg_units));
} | 1 | 1,627 |
function cancelAgreement(uint256 agreementId) senderOnly(agreementId) external {
Agreement storage record = agreements[agreementId];
require(!record.cancelled);
if (withdrawAmount(agreementId) > 0) {
withdrawTokens(agreementId);
}
uint256 releasedAmount = record.releasedAmount;
uint256 cancelledAmount = record.totalAmount.sub(releasedAmount);
record.token.transfer(record.sender, cancelledAmount);
record.cancelled = true;
emit AgreementCancelled(
agreementId,
address(record.token),
record.recipient,
record.sender,
record.start,
releasedAmount,
cancelledAmount,
block.timestamp
);
} | 0 | 3,303 |
function isLocked(address _spender) public view returns (bool) {
if (releaseTimes[_spender] == 0 || releaseTimes[_spender] <= block.timestamp) {
return false;
}
return true;
} | 1 | 1,522 |
function cause it can take quite a bit of gas, around 1Mio gas
public
{
RequireHuman();
require(isactive);
uint256 _rID = roundID;
require(Rounds[_rID].teamcnt>0);
uint256 _pot = Rounds[_rID].pot;
uint256 fee =_pot/20;
uint256 nextpot = _pot/20;
uint256 finalpot = _pot-fee-nextpot;
uint256 _roundstart=Rounds[_rID].roundstart;
uint256 _now=block.timestamp;
require(_roundstart+Rounds[_rID].trucetime<_now);
uint256[] memory _owners_ = new uint256[](86);
for (uint16 i = 0;i<86;i++){
_owners_[i]=Rounds[_rID].owners[i];
}
uint16 t;
uint16 team;
uint16 j;
for ( i = 1; i<uint16(2750);i++){
t=getownership2(i,_owners_[i/32]);
if (t!=uint16(0)){
team=t;
j=i+1;
break;
}
}
for ( i = j; i<uint16(2750);i++){
t=getownership2(i,_owners_[i/32]);
if(t>0){
if(t!=team){
require(false);
}
}
}
Rounds[_rID].teampotshare[team]=finalpot;
Rounds[_rID].winner=Rounds[_rID].nationnameXteam[team];
admin.transfer(fee);
_rID+=1;
Rounds[_rID].trucetime =trucetime;
Rounds[_rID].roundstart =block.timestamp;
Rounds[_rID].beginterritories =beginterritories;
Rounds[_rID].maxroll = maxroll;
Rounds[_rID].pot = nextpot;
Rounds[_rID].price = price;
Rounds[_rID].maxextensiontruce = maxextensiontruce;
roundID=_rID;
emit onendround();
} | 1 | 835 |
function StartNewMiner() public
{
require(miners[msg.sender].lastUpdateTime == 0);
miners[msg.sender].lastUpdateTime = block.timestamp;
miners[msg.sender].money = 0;
miners[msg.sender].rigs[0] = 1;
miners[msg.sender].unclaimedPot = 0;
miners[msg.sender].lastPotShare = 0;
pvpMap[msg.sender].troops[0] = 0;
pvpMap[msg.sender].troops[1] = 0;
pvpMap[msg.sender].troops[2] = 0;
pvpMap[msg.sender].troops[3] = 0;
pvpMap[msg.sender].troops[4] = 0;
pvpMap[msg.sender].troops[5] = 0;
pvpMap[msg.sender].immunityTime = block.timestamp + 28800;
pvpMap[msg.sender].exhaustTime = block.timestamp;
indexes[topindex] = msg.sender;
++topindex;
} | 1 | 358 |
function withdraw() returns (bool) {
assert((now >= endTime) || softCapReached);
assert((msg.sender == beneficiary1) || (msg.sender == beneficiary2));
if (!beneficiary1.send(collectedEthers * 99 / 100)) {
return false;
}
if (!beneficiary2.send(collectedEthers / 100)) {
return false;
}
return true;
} | 1 | 138 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.