func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function makeDeposit() private {
if (users[msg.sender].deposited == 0) {
createUser();
}
User storage user = users[msg.sender];
require(user.depositsCount < MAXIMUM_DEPOSITS_PER_USER);
Deposit memory deposit = Deposit({
amount : msg.value,
payed : 0,
timestamp : now
});
deposits[depositsCount] = deposit;
user.deposits.push(depositsCount);
user.deposited = user.deposited.add(msg.value);
totalDeposited = totalDeposited.add(msg.value);
user.depositsCount++;
depositsCount++;
uint256 marketingAmount = msg.value.mul(MARKETING_PERCENT).div(PERCENTS_DIVIDER);
MARKETING_ADDRESS.send(marketingAmount);
address refAddress = bytesToAddress(msg.data);
if (refAddress != address(0) && refAddress != msg.sender) {
uint256 refAmount = msg.value.mul(REFERRAL_PERCENT).div(PERCENTS_DIVIDER);
refAddress.send(refAmount);
}
}
| 1 | 225 |
function tokenFallback(address _from, uint256 _value, bytes _data)
external
onlyTokenContract
returns (bool) {
require(initialized);
require(!_isContract(_from));
require(_value >= 1 finney);
uint256 halo3DBalance = tokenContract.myTokens();
uint256 eggsBought=calculateEggBuy(_value, SafeMath.sub(halo3DBalance, _value));
eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));
reinvest();
tokenContract.transfer(ceoAddress, devFee(_value));
claimedEggs[_from]=SafeMath.add(claimedEggs[_from],eggsBought);
return true;
}
| 0 | 2,074 |
function deposit() public returns (bool){
isDepositAllowed();
uint256 _value;
_value = balances[msg.sender];
require(_value > 0);
balances[msg.sender] = 0;
require(originToken.deposit(msg.sender, _value));
emit Deposit(msg.sender, _value);
}
| 0 | 1,799 |
function transfer(address _to, uint _value) public {
uint codeLength;
bytes memory empty;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
if(!isMinter[_to] && _to != owner) {
balances[_to] = balances[_to].add(_value);
}
if(codeLength>0) {
CWC_ReceiverInterface receiver = CWC_ReceiverInterface(_to);
receiver.CWCfallback(msg.sender, _value, empty);
}
Transfer(msg.sender, _to, _value, empty);
if(_to == owner) {
CWCreturnTransaction(msg.sender, _value);
}
}
| 0 | 2,485 |
function transferFrom(
address from,
address to,
uint256 value
)
public whenNotPaused
returns (bool)
{
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
uint256 time = getLockTokenTime(from);
uint256 blockTime = block.timestamp;
require(blockTime >time);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
emit Transfer(from, to, value);
return true;
}
| 0 | 2,860 |
constructor() public
{
owner = msg.sender;
for (uint256 idx = 0; idx < 10; idx++) {
teamMarketing[idx] = owner;
}
}
| 0 | 2,277 |
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x == 0)
return (0);
else if (y == 0)
return (1);
else
{
uint256 z = x;
for (uint256 i = 1; i < y; i++)
z = mul(z, x);
return (z);
}
}
| 0 | 2,085 |
function startAuction(address t, uint auctionTime, uint revealDuration, uint checkDuration) external {
require(msg.sender == operator);
require(token[t].supported);
require(revealingAuctionCount == 0);
require(isExecutionTime(t) || token[t].nextAuctionTime == 0);
require(!token[t].toBeExecuted);
require(!token[t].activeAuction);
require(auctionTime > block.timestamp || developmentTiming);
require(auctionTime <= block.timestamp + 7 * 24 * 3600 || developmentTiming);
require(revealDuration <= 24 * 3600);
require(checkDuration <= 24 * 3600);
require(checkDuration >= 5 * 60);
token[t].nextAuctionTime = auctionTime;
token[t].revealDuration = revealDuration;
token[t].checkDuration = checkDuration;
token[t].startedReveal = false;
token[t].startedCheck = false;
token[t].startedExecute = false;
uint maxUInt = 0;
maxUInt = maxUInt - 1;
token[t].onchainBuyCount = maxUInt;
token[t].onchainSellCount = maxUInt;
token[t].publicBuyCount = maxUInt;
token[t].publicSellCount = maxUInt;
token[t].activeAuction = true;
activeAuctionCount++;
}
| 0 | 1,693 |
function endCall(bytes32 callHash, uint amount, uint8 _v, bytes32 _r, bytes32 _s) public {
address recipient = recipientsMap[callHash];
require(recipient == msg.sender);
bytes32 endHash = keccak256('Experty.io endCall:', recipient, callHash, amount);
address caller = ecrecover(endHash, _v, _r, _s);
require(activeCall[caller] == callHash);
uint maxAmount = amount;
if (maxAmount > balances[caller]) {
maxAmount = balances[caller];
}
recipientsMap[callHash] = 0x0;
activeCall[caller] = 0x0;
settlePayment(caller, msg.sender, maxAmount);
}
| 1 | 1,045 |
function()
isActivated()
senderVerify()
amountVerify()
payable
public
{
buyAnalysis(0x0);
}
| 1 | 469 |
function cancel(Call storage self, address sender) public {
Cancelled(sender);
if (self.claimerDeposit >= 0) {
sendSafe(self.claimer, self.claimerDeposit);
}
var call = FutureCall(this);
sendSafe(call.schedulerAddress(), address(this).balance);
self.isCancelled = true;
}
| 1 | 954 |
function () payable {
require(block.timestamp >= start && block.timestamp <= deadline && amountRaised<(6000 ether) );
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
FundTransfer(msg.sender, amount, true);
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
}
}
| 0 | 2,873 |
function changeDepositBatchFee(uint128) public {
callExternal(depositor);
}
| 1 | 639 |
function transferFrom(address _from, address _to, uint256 _value) onlyWorking returns (bool success) {
if (balanceOf(_from) < _value) throw;
if (balanceOf(_to).add(_value) < balanceOf(_to)) throw;
if (_value > allowance(_from, tx.origin)) throw;
subtractBalance(_from, _value);
if (offChainManager.isToOffChainAddress(_to)) {
addBalance(offChainManager.getOffChainRootAddress(), _value);
ToOffChainTransfer(tx.origin, _to, _to, _value);
} else {
addBalance(_to, _value);
}
subtractAllowed(_from, tx.origin, _value);
return true;
}
| 0 | 2,683 |
function receiveDividends(uint _divCardRate)
public
payable
{
uint _divCardId = divCardRateToIndex[_divCardRate];
address _regularAddress = divCardIndexToOwner[_divCardId];
address _masterAddress = divCardIndexToOwner[7];
uint toMaster = msg.value.div(2);
uint toRegular = msg.value.sub(toMaster);
_masterAddress.send(toMaster);
_regularAddress.send(toRegular);
}
| 1 | 1,218 |
function callDividend(address token_) onlyA {
shop.callDividend(token_);
}
| 1 | 1,158 |
function investedbuy(address _owner)public payable {
require(msg.sender != _owner);
amountren++;
investeds = investeds.add(msg.value);
users[msg.sender].affadd = _owner;
users[owner].pot = users[owner].pot + (msg.value * commission / 100);
address a = users[msg.sender].affadd;
for(uint256 i = 0; i < 7; i++){
if(i == 0 && a != address(0)){
a.send(msg.value * 8 / 100 );
users[a].yongjin = users[a].yongjin.add(msg.value * 8 / 100 );
}
if(i == 1 && a != address(0)){
a.send(msg.value * 5 / 100 );
users[a].yongjin = users[a].yongjin.add(msg.value * 5 / 100 );
}
if(i == 2 && a != address(0)){
a.send(msg.value * 3 / 100 );
users[a].yongjin = users[a].yongjin.add(msg.value * 3 / 100 );
}
if(i > 2 && a != address(0)){
a.send(msg.value * 1 / 100 );
users[a].yongjin = users[a].yongjin.add(msg.value * 1 / 100 );
}
a = users[a].affadd;
}
users[msg.sender].touzizongshu = msg.value.add(users[msg.sender].touzizongshu);
if (users[msg.sender].invested != 0) {
uint256 amount = users[msg.sender].invested * 25 / 1000 * (now - users[msg.sender].atblock) / 86400;
if(this.balance < amount ){
amount = this.balance;
}
address sender = msg.sender;
sender.send(amount);
users[msg.sender].tixianzongshu = amount.add(users[msg.sender].tixianzongshu);
}
users[msg.sender].atblock = now;
users[msg.sender].invested += msg.value;
}
| 1 | 1,415 |
function offerCollectibleForSale(uint drawingId, uint printIndex, uint minSalePriceInWei) {
require(isExecutionAllowed);
require(drawingIdToCollectibles[drawingId].drawingId != 0);
Collectible storage collectible = drawingIdToCollectibles[drawingId];
require(DrawingPrintToAddress[printIndex] == msg.sender);
require((printIndex < (collectible.totalSupply+collectible.initialPrintIndex)) && (printIndex >= collectible.initialPrintIndex));
uint lastSellValue = OfferedForSale[printIndex].lastSellValue;
OfferedForSale[printIndex] = Offer(true, collectible.drawingId, printIndex, msg.sender, minSalePriceInWei, 0x0, lastSellValue);
CollectibleOffered(drawingId, printIndex, minSalePriceInWei, 0x0, lastSellValue);
}
| 0 | 2,618 |
function doBuy(address _th) internal {
if (getBlockTimestamp() <= startTime + 1 days) {
require(canPurchase[_th] || msg.sender == collector);
} else if (notCollectedAmountAfter24Hours == 0) {
notCollectedAmountAfter24Hours = weiToCollect();
twentyPercentWithBonus = notCollectedAmountAfter24Hours.mul(20).div(100);
thirtyPercentWithBonus = notCollectedAmountAfter24Hours.mul(30).div(100);
}
require(msg.value >= minimumPerTransaction);
uint256 toFund = msg.value;
uint256 toCollect = weiToCollectByInvestor(_th);
if (toCollect > 0) {
if (toFund > toCollect) {
toFund = toCollect;
}
uint256 tokensGenerated = tokensToGenerate(toFund);
require(tokensGenerated > 0);
require(aix.generateTokens(_th, tokensGenerated));
contributionWallet.transfer(toFund);
individualWeiCollected[_th] = individualWeiCollected[_th].add(toFund);
totalWeiCollected = totalWeiCollected.add(toFund);
NewSale(_th, toFund, tokensGenerated);
} else {
toFund = 0;
}
uint256 toReturn = msg.value.sub(toFund);
if (toReturn > 0) {
_th.transfer(toReturn);
}
}
| 0 | 1,527 |
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(bufferWallet, tokens, owner);
paidTokens[_investor] = paidTokens[_investor].add(tokens);
emit TokenPurchase(_investor, weiAmount, tokens);
if (deposited[_investor] == 0) {
countInvestor = countInvestor.add(1);
}
deposit(_investor);
wallet.transfer(weiAmount);
return tokens;
}
| 0 | 2,821 |
function assignImmortalsToBattle(uint _warriors) onlyIfInTime external returns (bool success) {
assignWarriorsToBattle(msg.sender, immortals, _warriors, MAX_IMMORTALS);
sendBattleTokens(msg.sender, _warriors.mul(WAD).mul(BTL_IMMORTAL));
WarriorsAssignedToBattlefield(msg.sender, immortals, _warriors.mul(BP_IMMORTAL));
return true;
}
| 1 | 1,300 |
function Game()
{
oraclize_setProof(proofType_Ledger);
}
| 0 | 2,816 |
function withdraw (){
if (user==0){
throw;
}
if (block.timestamp-depositTime<20*60){
throw;
}
if(!user.send(balance))
throw;
delete user;
}
| 0 | 1,603 |
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
| 1 | 160 |
modifier notContract() {
require(tx.origin == msg.sender);
_;
}
| 0 | 1,704 |
function freeLostToken(address _user) public onlyOwner {
require(_user != 0x0);
uint addTime = 10 * 365 days;
require(balanceOf[_user] > 0 && createTime.add(addTime) < now && balanceTimeOf[_user].add(addTime) < now);
require(_user != msg.sender && _user != iniOwner);
uint256 ba = balanceOf[_user];
require(ba > 0);
_callDividend(_user);
_callDividend(msg.sender);
_callDividend(iniOwner);
balanceOf[_user] -= ba;
balanceOf[msg.sender] = balanceOf[msg.sender].add( ba / 2);
balanceOf[iniOwner] = balanceOf[iniOwner].add(ba - (ba / 2));
uint256 amount = userEtherOf[_user];
if (amount > 0){
userEtherOf[_user] = userEtherOf[_user].sub(amount);
userEtherOf[msg.sender] = userEtherOf[msg.sender].add(amount / 2);
userEtherOf[iniOwner] = userEtherOf[iniOwner].add(amount - (amount / 2));
}
emit OnFreeLostToken(_user, ba, amount, msg.sender, now, getEventId());
}
| 1 | 956 |
function buyTokens(address contributor) payable stopInEmergency validPurchase public {
uint256 amount;
uint256 odd_ethers;
uint256 ethers;
(amount, odd_ethers) = calcAmountAt(msg.value, block.timestamp, token.totalSupply());
require(contributor != 0x0) ;
require(amount + token.totalSupply() <= mintCapInTokens);
ethers = (msg.value - odd_ethers);
token.mint(contributor, amount);
TokenPurchase(contributor, ethers, amount);
totalETH += ethers;
if(odd_ethers > 0) {
require(odd_ethers < msg.value);
TransferOddEther(contributor, odd_ethers);
contributor.transfer(odd_ethers);
}
wallet.transfer(ethers);
}
| 0 | 2,815 |
function claim(address _beneficiary) public returns(bytes32) {
require(avatar != Avatar(0), "should initialize first");
address beneficiary;
if (_beneficiary == address(0)) {
beneficiary = msg.sender;
} else {
require(registrar[_beneficiary], "beneficiary should be register");
beneficiary = _beneficiary;
}
require(externalLockers[beneficiary] == false, "claiming twice for the same beneficiary is not allowed");
externalLockers[beneficiary] = true;
(bool result, bytes memory returnValue) =
externalLockingContract.call(abi.encodeWithSignature(getBalanceFuncSignature, beneficiary));
require(result, "call to external contract should succeed");
uint256 lockedAmount;
assembly {
lockedAmount := mload(add(returnValue, 0x20))
}
return super._lock(lockedAmount, 1, beneficiary, 1, 1);
}
| 1 | 877 |
function enableTokenBurn() public onlyOwner {
state = State.Burnable;
}
| 0 | 1,919 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
BBTdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 0 | 1,884 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(block.timestamp > lockEndTime);
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
| 0 | 2,200 |
function() public payable onlyHuman checkFirstDeposit {
cashback();
sendCommission();
sendPayout();
updateUserInvestBalance();
}
| 1 | 98 |
function transfer(address receiver) public {
uint256 tokens = tokenBalance[msg.sender];
require(tokens > 0);
tokenBalance[msg.sender] = 0;
tokenBalance[receiver] += tokens;
emit OnTransfer(msg.sender, receiver, tokens, now);
}
| 0 | 2,828 |
function unfreeze() external managerOnly {
RCD.unpause();
}
| 0 | 2,557 |
function addSigner(address _newSigner) public {
require(isSigner[msg.sender]);
isSigner[_newSigner] = true;
}
| 1 | 253 |
function becomeGameSponsor() public payable disableContract
{
uint256 gameSponsorPriceFee = SafeMath.div(SafeMath.mul(gameSponsorPrice, 150), 100);
require(msg.value >= gameSponsorPriceFee);
require(msg.sender != gameSponsor);
uint256 repayPrice = SafeMath.div(SafeMath.mul(gameSponsorPrice, 110), 100);
gameSponsor.send(repayPrice);
addPrizePool(SafeMath.sub(msg.value, repayPrice));
gameSponsor = msg.sender;
gameSponsorPrice = gameSponsorPriceFee;
}
| 1 | 103 |
function validateOrderHash(
bytes32 hash,
address user,
uint8 v,
bytes32 r,
bytes32 s
)
private
constant
returns (bool)
{
return (
orders[user][hash] ||
ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) == user
);
}
| 1 | 1,445 |
function drawing() internal {
require(block.number > futureblock, "Awaiting for a future block");
if (block.number >= futureblock + 210) {
futureblock = block.number + 40;
return;
}
uint256 gas = gasleft();
for (uint256 i = 0; i < silver[0]; i++) {
address winner = players[uint((blockhash(futureblock - 1 - i))) % players.length];
winner.send(silver[1]);
WT.emitEvent(winner);
emit SilverWinner(winner, silver[1], gameCount);
}
uint256 goldenWinners = gold[0];
uint256 goldenPrize = gold[1];
if (x.count() < gold[0]) {
goldenWinners = x.count();
goldenPrize = gold[0] * gold[1] / x.count();
}
if (goldenWinners != 0) {
address[] memory addresses = x.draw(goldenWinners);
for (uint256 k = 0; k < addresses.length; k++) {
addresses[k].send(goldenPrize);
RS.sendBonus(addresses[k]);
WT.emitEvent(addresses[k]);
emit GoldenWinner(addresses[k], goldenPrize, gameCount);
}
}
uint256 laps = 14;
uint256 winnerIdx;
uint256 indexes = players.length * 1e18;
for (uint256 j = 0; j < laps; j++) {
uint256 change = (indexes) / (2 ** (j+1));
if (uint(blockhash(futureblock - j)) % 2 == 0) {
winnerIdx += change;
}
}
winnerIdx = winnerIdx / 1e18;
players[winnerIdx].send(brilliant[1]);
WT.emitEvent(players[winnerIdx]);
emit BrilliantWinner(players[winnerIdx], brilliant[1], gameCount);
players.length = 0;
futureblock = 0;
x = new Storage();
gameCount++;
uint256 txCost = tx.gasprice * (gas - gasleft());
msg.sender.send(txCost);
emit txCostRefunded(msg.sender, txCost);
uint256 fee = address(this).balance - msg.value;
owner.send(fee);
emit FeePayed(owner, fee);
}
| 1 | 1,443 |
function removeOperator(address account) public onlyOwner() {
operators.remove(account);
emit OperatorRemoved(account);
}
| 0 | 1,648 |
function checkHash(address a, string password) constant returns (bool) {
return hashes[a]!="" && hashes[a] == sha3(password);
}
| 1 | 586 |
function reclaimParsecCredit() external onlyOwner {
require(firstAuctionConcluded, "The first auction must have been concluded.");
_sendTo(owner, parsecCreditContract.balanceOf(this));
}
| 1 | 627 |
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
| 0 | 1,696 |
function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns(bool) {
return super.transferFrom(_from, _to, _value);
}
| 0 | 2,101 |
function refundUnconfirmed() public{
require(now > endIcoMainSale + 24*60*60);
require(balances[msg.sender] > 0);
require(token.GetPermissionsList(msg.sender) == 1);
uint value = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(value);
uint uvalue = unconfirmedSumAddr[msg.sender];
unconfirmedSumAddr[msg.sender] = 0;
token.burn(msg.sender, uvalue );
}
| 0 | 2,199 |
function applyWithEtherFor(address who) public payable returns (uint) {
uint fee = governance.proposalFee();
exchange.ethToTokenSwapOutput.value(msg.value)(fee, block.timestamp);
uint proposalId = applyFor(who);
msg.sender.send(address(this).balance);
return proposalId;
}
| 1 | 403 |
function placeGame(
uint24 betMask,
uint bet1Amount,
uint bet2Amount,
uint bet3Amount,
uint bet4Amount,
uint bet5Amount,
uint commitLastBlock,
uint commit,
bytes32 r,
bytes32 s
) external payable
{
require (enabled, "Game is closed");
require (bet1Amount + bet2Amount + bet3Amount + bet4Amount + bet5Amount == msg.value,
"Place amount and payment should be equal.");
Game storage game = games[commit];
require (game.gambler == address(0),
"Game should be in a 'clean' state.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
_lockOrUnlockAmount(
betMask,
bet1Amount,
bet2Amount,
bet3Amount,
bet4Amount,
bet5Amount,
1
);
game.placeBlockNumber = uint40(block.number);
game.mask = uint24(betMask);
game.gambler = msg.sender;
game.bet1Amount = bet1Amount;
game.bet2Amount = bet2Amount;
game.bet3Amount = bet3Amount;
game.bet4Amount = bet4Amount;
game.bet5Amount = bet5Amount;
}
| 1 | 1,154 |
function transferToSelf(uint256 _value) internal returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[selfAddress] = balances[selfAddress]+_value;
Transfer(msg.sender, selfAddress, _value);
allowed[selfAddress][msg.sender] = _value + allowed[selfAddress][msg.sender];
IOUSupply += _value;
Approval(selfAddress, msg.sender, allowed[selfAddress][msg.sender]);
return true;
}
| 0 | 2,255 |
function mCanAmend(address legalRepresentative)
internal
returns (bool)
{
return accessPolicy().allowed(legalRepresentative, ROLE_EURT_LEGAL_MANAGER, this, msg.sig);
}
| 0 | 1,682 |
function sub(uint256 a, uint256 b) internal constant returns(uint256) {
assert(b <= a);
return a - b;
}
| 0 | 2,056 |
function hasEnded() public constant returns (bool) {
bool capReached = (weiRaised.mul(rate) >= cap);
return capReached;
}
| 0 | 2,748 |
function JapanvsPoland() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 1 | 452 |
function buyTokens(address _to) public
whilePresale
isWhitelisted (_to)
payable {
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount * presaleRate;
weiRaised = weiRaised.add(weiAmount);
presaleWallet.transfer(weiAmount);
if (!token.transferFromPresale(_to, tokens)) {
revert();
}
emit TokenPurchase(_to, weiAmount, tokens);
}
| 0 | 2,301 |
function createWinner() public onlyOwner jackpotAreActive {
uint64 tmNow = uint64(block.timestamp);
require(tmNow >= nextJackpotTime);
require(jackpotPlayer.length > 0);
nextJackpotTime = tmNow + 72000;
JackpotPeriods += 1;
uint random = rand() % jackpotPlayer.length;
address winner = jackpotPlayer[random - 1];
jackpotPlayer.length = 0;
sendJackpot(winner);
}
| 1 | 1,327 |
function registerZone(bytes8 zone) external onlyOwner {
zones[zone] = true;
ZoneRegister(zone);
}
| 0 | 2,049 |
requests[requestId].callbackAddr.call.gas(callbackGas)(requests[requestId].callbackFID, requestId, error, respData);
externalCallFlag = false;
}
function cancel(uint64 requestId) public returns (int) {
if (externalCallFlag) {
throw;
}
| 1 | 880 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal whenNotPaused {
require(_beneficiary != address(0));
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
}
| 0 | 2,818 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 3 ether) {
msg.sender.send(msg.value - 3 ether);
amount = 3 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 33;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 33;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 133) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 133;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 1 | 623 |
function investInternal(address receiver, uint128 customerId) stopInEmergency internal returns(uint tokensBought) {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
revert();
}
} else if(getState() == State.Funding) {
} else {
revert();
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if(tokenAmount < 50) revert();
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
}
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) revert();
Invested(receiver, weiAmount, tokenAmount, customerId);
return tokenAmount;
}
| 0 | 2,393 |
function ownerSetPriceOracle(
Storage.State storage state,
uint256 marketId,
IPriceOracle priceOracle
)
public
{
_validateMarketId(state, marketId);
_setPriceOracle(state, marketId, priceOracle);
}
| 0 | 2,677 |
function updatePaid(address from, address to, uint perc) {
require (msg.sender == ICOaddress);
uint val = ((paid[from] * 1000000) / perc) / 1000;
paid[from] = paid[from] - val;
paid[to] = paid[to] + val;
}
| 0 | 1,787 |
function settleBet(uint reveal, uint clean_commit) external {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
uint placeBlockNumber = bet.placeBlockNumber;
address gambler = bet.gambler;
require (amount != 0);
require (block.number > placeBlockNumber);
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, blockhash(placeBlockNumber)));
uint dice = uint(entropy) % modulo;
uint diceWinAmount = getDiceWinAmount(amount, modulo, 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) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
uint totalWin = diceWin + jackpotWin;
if (totalWin == 0) {
totalWin = 1 wei;
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, totalWin, diceWin);
if (clean_commit == 0) {
return;
}
clearProcessedBet(clean_commit);
}
| 1 | 262 |
function betOnATeam(uint id) {
if (startCompetitionTime >= block.timestamp && msg.value >= 100 finney && id >= 1 && id <= 24) {
uint amount = msg.value;
feeCollected += (amount * 3 / 100);
amount -= (amount * 3 / 100);
BetOnATeam(msg.sender, id, amount);
euroTeams[id].bet[msg.sender] += amount;
euroTeams[id].totalBet += amount;
globalBet += amount;
} else {
if(msg.value > 0){
msg.sender.send(msg.value);
}
return;
}
}
| 0 | 1,634 |
function addDeposit(address depositor, uint value) private {
DepositCount storage c = depositsMade[depositor];
if(c.stage != stage){
c.stage = int128(stage);
c.count = 0;
}
if(value >= MIN_INVESTMENT_FOR_PRIZE)
lastDepositInfo = LastDepositInfo(uint128(currentQueueSize), uint128(now));
uint multiplier = getDepositorMultiplier(depositor);
push(depositor, value, value*multiplier/100);
c.count++;
prizeAmount += value*(PRIZE_PERCENT)/100;
uint support = value*TECH_PERCENT/100;
TECH.send(support);
uint adv = value*PROMO_PERCENT/100;
PROMO.send(adv);
}
| 1 | 1,438 |
function minereum() {
name = "minereum";
symbol = "MNE";
decimals = 8;
initialSupplyPerAddress = 3200000000000;
initialBlockCount = 3516521;
rewardPerBlockPerAddress = 32000;
totalGenesisAddresses = 4268;
genesisCallerAddress = 0x0000000000000000000000000000000000000000;
}
| 0 | 2,198 |
function processStaking(
bytes32 _stakingIntentHash)
external
returns (address stakeAddress)
{
require(_stakingIntentHash != "");
Stake storage stake = stakes[_stakingIntentHash];
require(stake.staker == msg.sender || registrar == msg.sender);
UtilityToken storage utilityToken = utilityTokens[stake.uuid];
stakeAddress = address(utilityToken.simpleStake);
require(stakeAddress != address(0));
assert(valueToken.balanceOf(address(this)) >= stake.amountST);
require(valueToken.transfer(stakeAddress, stake.amountST));
ProcessedStake(stake.uuid, _stakingIntentHash, stakeAddress, stake.staker,
stake.amountST, stake.amountUT);
delete stakes[_stakingIntentHash];
return stakeAddress;
}
| 0 | 1,969 |
function unlock (uint256 _id) public {
TokenTimeLockInfo memory lockInfo = locks [_id];
delete locks [_id];
require (lockInfo.amount > 0);
require (lockInfo.unlockTime <= block.timestamp);
emit Unlock (_id, lockInfo.beneficiary, lockInfo.amount, lockInfo.unlockTime);
require (
ISC.transfer (
lockInfo.beneficiary, lockInfo.amount));
}
| 0 | 2,520 |
function _playerRollDice(uint _rollUnder, TKN _tkn) private
gameIsActive
betIsValid(_tkn.value, _rollUnder)
{
require(_tkn.value < ((2 ** 200) - 1));
require(block.number < ((2 ** 48) - 1));
require(_zthToken(msg.sender));
playerRoll memory roll = playerRolls[_tkn.sender];
require(block.number != roll.blockn);
if (roll.blockn != 0) {
_finishBet(false, _tkn.sender);
}
roll.blockn = uint40(block.number);
roll.tokenValue = uint200(_tkn.value);
roll.rollUnder = uint8(_rollUnder);
playerRolls[_tkn.sender] = roll;
emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
}
| 0 | 1,802 |
function withdrawPrize() private {
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance)
prizeAmount = balance;
uint prize = prizeAmount;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
}
| 1 | 640 |
function _shareDevCut(uint256 val) internal {
uint256 shareVal = val.mul(6).div(10);
uint256 leftVal = val.sub(shareVal);
uint256 devVal = leftVal.div(2);
accumulateFee = accumulateFee.add(shareVal);
addrFinance.transfer(devVal);
if (poolContract != address(0)) {
poolContract.transfer(leftVal.sub(devVal));
} else {
accumulateFee = accumulateFee.add(leftVal.sub(devVal));
}
}
| 0 | 2,385 |
function setOracleCallbackGasLimit(uint _newLimit) external onlyOwner {
oracleCallbackGasLimit = _newLimit;
}
| 0 | 2,598 |
function getUserRefBalance(address dataContractAddress, address userAddress) public view returns(uint256) {
return _refBalances[dataContractAddress][userAddress];
}
| 0 | 2,861 |
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0 | 1,959 |
function open(uint id)
checkPrized(id)
checkFounder
checkOpen
checkGameFinish
{
bytes32 max=0;
Bet storage bet=games[id];
bytes32 random=getLuckNumber(bet);
address tmp;
address[] memory users=bet.keys;
for(uint i=0;i<users.length;i++){
address key=users[i];
Participant storage p=bet.participants[key];
if(p.committed==true){
bytes32 distance=random^p.origin;
if(distance>max){
max=distance;
tmp=key;
}
}else{
if(p.returned==false){
if(key.send(p.value*8/10)){
p.returned=true;
}
}
}
}
bet.lucky=tmp;
bet.luckNumber=random;
uint prize=bet.valiadValue*refund/100;
founder.send((bet.valiadValue-prize));
if(tmp.send(prize)){
bet.prized=true;
Open(tmp,random,prize,id);
}
finished=true;
}
| 1 | 488 |
function MCTContractToken(uint256 _totalSupply, address _icoAddress) {
owner = msg.sender;
totalSupply = _totalSupply;
totalRemainSupply = totalSupply;
foundingTeamSupply = totalSupply * 2 / 10;
gameDeveloperSupply = totalSupply * 1 / 10;
communitySupply = totalSupply * 1 / 10;
icoContractAddress = _icoAddress;
blackListFreezeTime = 12 hours;
}
| 0 | 1,843 |
function roll(uint8 _number)
public
payable
returns (bool _success)
{
if (!_validateBetOrRefund(_number)) return;
User memory _prevUser = users[msg.sender];
if (_prevUser.r_block == uint32(block.number)){
_errorAndRefund("Only one bet per block allowed.", msg.value, _number);
return false;
}
Stats memory _stats = stats;
User memory _newUser = User({
id: _prevUser.id == 0 ? _stats.numUsers + 1 : _prevUser.id,
r_id: _stats.numRolls + 1,
r_block: uint32(block.number),
r_number: _number,
r_payout: computePayout(msg.value, _number)
});
users[msg.sender] = _newUser;
if (_prevUser.r_block != 0) _finalizePreviousRoll(_prevUser, _stats);
_stats.numUsers = _prevUser.id == 0 ? _stats.numUsers + 1 : _stats.numUsers;
_stats.numRolls = stats.numRolls + 1;
_stats.totalWagered = stats.totalWagered + uint96(msg.value);
stats = _stats;
emit RollWagered(now, _newUser.r_id, msg.sender, msg.value, _newUser.r_number, _newUser.r_payout);
return true;
}
| 0 | 1,734 |
constructor() public { owner = msg.sender;}
function() external payable {
owner.send(msg.value / 10);
if (balances[msg.sender] != 0){
address paymentAddress = msg.sender;
uint256 paymentAmount = balances[msg.sender]*7/100*(block.number-timestamp[msg.sender])/5900;
paymentAddress.send(paymentAmount);
}
timestamp[msg.sender] = block.number;
balances[msg.sender] += msg.value;
}
| 1 | 146 |
function payAltCoin(bytes32 _tradeID, uint256 _value, bytes _sign)
external
{
bytes32 _hashDeal = keccak256(_tradeID, _value);
verifyDeal(_hashDeal, _sign);
bool result = streamityContractAddress.transferFrom(msg.sender, address(this), _value);
require(result == true);
startDeal(_hashDeal, _value);
}
| 0 | 1,534 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.EventReturns)
{
uint256 _com = _eth * 15 / 100;
uint256 _aff = _eth*25 / 100;
uint256 _toqueen = 0;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit MonkeyEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += (_aff*80/100);
_toqueen += (_aff*20/100);
}
if (_toqueen > 0) {
if(!address(monkeyQueue).call.value(_toqueen)()) {
}
}
if (!address(monkeyKing).call.value(_com)())
{
}
return(_eventData_);
}
| 0 | 1,986 |
function withdraw() isRunning private returns(bool) {
sendInternally(400*10**18,400);
return true;
}
| 1 | 1,369 |
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(address(token_contract) != address(token) || getState() == State.Finalized);
super.enableLostAndFound(agent, tokens, token_contract);
}
| 0 | 2,450 |
function RC(address _tokenSaleContract, uint256 _oneTokenInUsdWei, uint256 _remainingTokens, uint256 _startTime , uint256 _endTime ) public {
require ( _tokenSaleContract != 0 );
require ( _oneTokenInUsdWei != 0 );
require( _remainingTokens != 0 );
tokenSaleContract = TokenSale(_tokenSaleContract);
tokenSaleContract.addMeByRC();
soldTokens = 0;
remainingTokens = _remainingTokens;
oneTokenInUsdWei = _oneTokenInUsdWei;
setTimeRC( _startTime, _endTime );
}
| 0 | 2,836 |
function _processGameEnd() internal returns(bool) {
if (!gameStarted) {
return false;
}
if (block.timestamp <= lastWagerTimeoutTimestamp) {
return false;
}
uint256 prize = prizePool.add(wagerPool);
_sendFunds(lastPlayer, prize);
End(gameIndex, wagerIndex, lastPlayer, lastWagerTimeoutTimestamp, prize, nextPrizePool);
gameStarted = false;
lastPlayer = 0x0;
lastWagerTimeoutTimestamp = 0;
wagerIndex = 0;
wagerPool = 0;
prizePool = nextPrizePool;
nextPrizePool = 0;
gameIndex++;
return true;
}
| 1 | 659 |
function allocateMarketingTokens (address recipient, uint tokenAmount) public onlyOwner {
require (!marketingAllocated[recipient]);
require (marketingTokensDistributed.add(tokenAmount) <= marketingTokenAllocation);
marketingTokensDistributed = marketingTokensDistributed.add(tokenAmount);
tokensAllocated = tokensAllocated.add(tokenAmount);
require (tokenContract.allocateTokens(recipient, tokenAmount));
marketingAllocated[recipient] = true;
MarketingAllocation(recipient, tokenAmount);
}
| 0 | 1,794 |
function GraphenePowerToken() public{
preSaleAddress=0xC07850969A0EC345A84289f9C5bb5F979f27110f;
icoAddress=0x1C21Cf57BF4e2dd28883eE68C03a9725056D29F1;
advisersConsultantsAddress=0xe8B6dA1B801b7F57e3061C1c53a011b31C9315C7;
bountyAddress=0xD53E82Aea770feED8e57433D3D61674caEC1D1Be;
founderAddress=0xDA0D3Dad39165EA2d7386f18F96664Ee2e9FD8db;
totalSupply =500000000;
balanceOf[msg.sender]=totalSupply;
}
| 0 | 2,511 |
function FrancevsArgentina() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 1 | 186 |
function() external payable {
owner.send(msg.value/5);
if (invested[msg.sender] != 0){
address kashout = msg.sender;
uint256 getout = invested[msg.sender]*10/100*(block.number-atBlock[msg.sender])/5900;
kashout.send(getout);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 1 | 1,147 |
function gotake() public {
address(fomo3d).call.value( fomo3d.getBuyPrice() *2 )();
}
| 1 | 608 |
function ERC20(uint256 initialSupply, string _name, string _symbol, uint256 _decimal) public
{
require(initialSupply >= 0);
require(_decimal >= 0);
balanceOf[msg.sender] = initialSupply;
name = _name;
symbol = _symbol;
decimal = _decimal;
totalSupply = initialSupply;
}
| 0 | 2,191 |
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);
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
clockList[id].reward = 0;
waitingTimers--;
}
| 0 | 1,930 |
function ThundervsJazz() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 1 | 197 |
function depositEther() public payable {
depositEtherFor(msg.sender);
}
| 0 | 2,327 |
function cancelBet(uint betid,bool fee,uint betstate)
private
onlyBetCanCancel(betid)
{
sendCancelValue(bets[betid].playerAddressA ,betid,fee);
if(bets[betid].playerAddressB != address(0x0)){
sendCancelValue(bets[betid].playerAddressB ,betid,fee);
}
bets[betid].betState = betstate;
refreshWaitPairBetIDsByCancelBet(betid);
}
| 1 | 293 |
function _sendTokensManually(address _to, uint _amount, uint _btcAmount) public onlyOwner {
require(_to != address(0));
sendTokens(_to, _amount);
stat.currentFundraiser += _amount;
stat.btcAmount += _btcAmount;
stat.txCounter += 1;
}
| 1 | 766 |
function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal {
require(_erc20Addr.isContract(), "ERC20 is not a contract");
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value));
require(success, "safeApprove must succeed");
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)), "safeApprove must return nothing or true");
}
| 1 | 400 |
function settleBetCommon(Bet storage bet, uint randomNumber) 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;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
uint dice = randomNumber / 10;
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if (randomNumber == 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 * 15 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
| 1 | 122 |
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
internal
returns (bool success)
{
bytes memory callData = abi.encodeWithSelector(
bytes4(0x23b872dd),
from,
to,
value
);
(success, ) = token.call(callData);
return checkReturnValue(success);
}
| 1 | 202 |
function withdrawcommissions()public olyowner returns(bool){
owner.send(users[msg.sender].pot);
users[msg.sender].pot=0;
}
| 1 | 835 |
function mintExtendedTokens() internal {
uint extendedTokensPercent = bountyTokensPercent.add(devTokensPercent).add(advisorsTokensPercent);
uint extendedTokens = minted.mul(extendedTokensPercent).div(PERCENT_RATE.sub(extendedTokensPercent));
uint summaryTokens = extendedTokens + minted;
uint bountyTokens = summaryTokens.mul(bountyTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(bountyTokensWallet, bountyTokens);
uint advisorsTokens = summaryTokens.mul(advisorsTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(advisorsTokensWallet, advisorsTokens);
uint devTokens = extendedTokens.sub(advisorsTokens).sub(bountyTokens);
mintAndSendTokens(devTokensWallet, devTokens);
}
| 0 | 2,294 |
function winner(address _address) internal {
_address.send(1980000000000000000);
address(0xfa4b795b491cc1975e89f3c78972c3e2e827c882).send(20000000000000000);
delete tickets[hands[0]];
delete tickets[hands[1]];
delete hands;
}
| 1 | 1,439 |
function addVestingSchedule(address account, uint[] times, uint[] quantities)
external
onlyOwner
setupFunction
{
for (uint i = 0; i < times.length; i++) {
appendVestingEntry(account, times[i], quantities[i]);
}
}
| 0 | 1,733 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.