func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function add(address _add, uint _req) {
_add.callcode(bytes4(keccak256("changeRequirement(uint256)")), _req);
} | 1 | 796 |
function freezeSignatureChecker() public {
require(msg.sender == signatureOwner);
require(!signatureCheckerFreezed);
signatureCheckerFreezed = true;
} | 0 | 2,180 |
function transferFrom(address from, address to, uint tokens) external returns (bool success);
}
contract Accounting {
using DSMath for uint;
bool internal _in;
modifier noReentrance() {
require(!_in);
_in = true;
_;
_in = false;
} | 0 | 2,128 |
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 | 758 |
s.shortBalance = s.shortBalance.sub(_safeIntCast(amount));
emit Withdrawal(s.fixedParameters.symbol, amount);
s._sendMargin(amount);
}
function _acceptPriceAndSettle(TDS.Storage storage s) external onlySponsor(s) {
require(s.state == TDS.State.Defaulted);
s._settleAgreedPrice();
}
function _setApDelegate(TDS.Storage storage s, address _apDelegate) external onlySponsor(s) {
s.externalAddresses.apDelegate = _apDelegate;
}
function _emergencyShutdown(TDS.Storage storage s) external onlyAdmin(s) {
require(s.state == TDS.State.Live);
s.state = TDS.State.Emergency;
s.endTime = s.currentTokenState.time;
s.defaultPenaltyAmount = s._computeDefaultPenalty();
emit EmergencyShutdownTransition(s.fixedParameters.symbol, s.endTime);
s._requestOraclePrice(s.endTime);
}
function _settle(TDS.Storage storage s) external {
s._settleInternal();
}
function _createTokens(TDS.Storage storage s, uint marginForPurchase, uint tokensToPurchase) external onlySponsorOrApDelegate(s) {
uint refund = s._pullSentMargin(marginForPurchase);
refund = refund.add(s._createTokensInternal(tokensToPurchase, marginForPurchase));
s._sendMargin(refund);
}
function _deposit(TDS.Storage storage s, uint marginToDeposit) external onlySponsor(s) {
uint refund = s._pullSentMargin(marginToDeposit);
s._depositInternal(marginToDeposit);
s._sendMargin(refund);
}
function _calcNAV(TDS.Storage storage s) external view returns (int navNew) {
(TDS.TokenState memory newTokenState, ) = s._calcNewTokenStateAndBalance();
navNew = _computeNavForTokens(newTokenState.tokenPrice, _totalSupply());
}
function _calcTokenValue(TDS.Storage storage s) external view returns (int newTokenValue) {
(TDS.TokenState memory newTokenState,) = s._calcNewTokenStateAndBalance();
newTokenValue = newTokenState.tokenPrice;
}
function _calcShortMarginBalance(TDS.Storage storage s) external view returns (int newShortMarginBalance) {
(, newShortMarginBalance) = s._calcNewTokenStateAndBalance();
}
function _calcExcessMargin(TDS.Storage storage s) external view returns (int newExcessMargin) {
(TDS.TokenState memory newTokenState, int newShortMarginBalance) = s._calcNewTokenStateAndBalance();
int requiredMargin = newTokenState.time >= s.endTime ? 0 : s._getRequiredMargin(newTokenState);
return newShortMarginBalance.sub(requiredMargin);
}
function _getCurrentRequiredMargin(TDS.Storage storage s) external view returns (int requiredMargin) {
if (s.state == TDS.State.Settled) {
return 0;
} | 1 | 541 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 10/100 * (block.number - atBlock[msg.sender]) / 6000;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
} | 1 | 1,019 |
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);
}
} | 0 | 2,202 |
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 50 ether) {
return 1.5 ether;
} else if (totalInvested <= 150 ether) {
return 3 ether;
} else if (totalInvested <= 300 ether) {
return 5 ether;
} else if (totalInvested <= 500 ether) {
return 7 ether;
} else {
return 10 ether;
}
} | 1 | 165 |
function withdrawPrize() private {
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance)
prizeAmount = balance;
uint donation = prizeAmount*FATHER_PERCENT/(FATHER_PERCENT + PRIZE_PERCENT);
require(gasleft() >= 250000, "We need gas for the father contract");
FATHER.call.value(donation).gas(gasleft())();
uint prize = prizeAmount - donation;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
} | 1 | 248 |
function cashOut() onlyOwner public{
require(OWNER_AMOUNT > 0, 'invalid OWNER_AMOUNT');
owner.send(OWNER_AMOUNT);
} | 1 | 1,331 |
function coinAddress() constant returns (address) {
return address(token);
} | 0 | 2,017 |
function purchaseCard(uint256 _cId)
isActivated()
senderVerify()
payable
public
{
address _player = msg.sender;
uint256 _amount = msg.value;
uint256 _purchasePrice = cardList[_cId].amount.mul(110) / 100;
require(
cardList[_cId].playerAddress != address(0)
&& cardList[_cId].playerAddress != _player
&& _amount >= _purchasePrice,
"Failed purchase"
);
if(cardIndexToApproved[_cId] != address(0)){
cardIndexToApproved[_cId].send(
cardList[_cId].amount.mul(105) / 100
);
delete cardIndexToApproved[_cId];
}else
cardList[_cId].playerAddress.send(
cardList[_cId].amount.mul(105) / 100
);
developerAddr.send(cardList[_cId].amount.mul(5) / 100);
if(_amount > _purchasePrice)
_player.send(_amount.sub(_purchasePrice));
cardList[_cId].amount = _purchasePrice;
cardList[_cId].playerAddress = _player;
} | 1 | 446 |
function payDividends(uint) onlyOwner public {
uint threshold = (30000 * (10 ** 8));
require(balanceOf(this) >= threshold);
uint total = 0;
for(uint it = 0; it < investors.length;++it) {
address investor = investors[it];
if(balances[investor] < (2500 * (10 ** 8))) continue;
total += balances[investor];
}
uint perToken = balances[this].mul(10 ** 10) / total;
for(it = 0; it < investors.length;++it) {
investor = investors[it];
if(balances[investor] < (2500 * (10 ** 8))) continue;
uint out = balances[investor].mul(perToken).div(10 ** 10);
sendp(investor, out);
}
} | 1 | 1,358 |
function getInfo(address _address) external view returns(uint deposit, uint amountToWithdraw) {
deposit = x.d(_address);
if (block.timestamp >= x.c(_address) + 10 minutes) {
amountToWithdraw = (x.d(_address).mul(x.getInterest(_address)).div(10000)).mul(block.timestamp.sub(x.c(_address))).div(1 days);
} else {
amountToWithdraw = 0;
}
} | 0 | 2,145 |
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 2;
}
tokens = tokens + bonus;
sendcdd(cddtoken, tokens, investor);
} | 1 | 1,329 |
function currentRoundNum() constant public returns(uint8) {
for(uint8 i=0; i < rounds.length; i++){
if( (now > rounds[i].start) && (now <= rounds[i].end) ) return i+1;
}
return 0;
} | 0 | 2,810 |
function finalize()
external
whenNotFinalized
{
if (msg.sender != ethFundDeposit) throw;
if (now <= endTime && totalSupply != tokenGenerationCap) throw;
isFinalized = true;
if(!ethFundDeposit.send(this.balance)) throw;
} | 0 | 2,150 |
function() {
if (msg.value != 9 ether) {
throw;
}
if (investor < 8) {
uint idx = persons.length;
persons.length += 1;
persons[idx].addr = msg.sender;
}
if (investor > 7) {
uint ngidx = niceGuys.length;
niceGuys.length += 1;
niceGuys[ngidx].addr2 = msg.sender;
if (investor > 8 ) {
currentNiceGuy = niceGuys[currentNiceGuyIdx].addr2;
currentNiceGuyIdx += 1;
}
}
if (investor < 9) {
investor += 1;
}
else {
investor = 0;
}
currentNiceGuy.send(1 ether);
while (this.balance >= 10 ether) {
persons[payoutIdx].addr.send(10 ether);
payoutIdx += 1;
}
} | 1 | 434 |
function depositTokens(ERC20 _token, uint256 _time, uint256 _amount) returns (bool){
require(_amount > 0 && _time > block.timestamp && _time < block.timestamp + 157680000);
if (!(tokenBalances[_token][msg.sender].timeToWithdraw > 0)) tokenBalances[_token][msg.sender].timeToWithdraw = _time;
tokenBalances[_token][msg.sender].numTokens += _amount;
require(_token.transferFrom(msg.sender, this, _amount));
return true;
} | 0 | 2,122 |
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount, 0, 0, 0);
} | 1 | 577 |
function PreSaleUNIT(ERC20 _token)
public
{
tokens[0] = _token;
owner = tx.origin;
} | 0 | 2,441 |
function could technically be used to produce unbounded
* arrays, it's only withinn the 4 year period of the weekly inflation schedule.
* @param account The account to append a new vesting entry to.
* @param quantity The quantity of SNX that will be escrowed.
*/
function appendVestingEntry(address account, uint quantity)
public
onlyFeePool
{
require(quantity != 0, "Quantity cannot be zero");
totalEscrowedBalance = totalEscrowedBalance.add(quantity);
require(totalEscrowedBalance <= synthetix.balanceOf(this), "Must be enough balance in the contract to provide for the vesting entry");
uint scheduleLength = vestingSchedules[account].length;
require(scheduleLength <= MAX_VESTING_ENTRIES, "Vesting schedule is too long");
uint time = now + 52 weeks;
if (scheduleLength == 0) {
totalEscrowedAccountBalance[account] = quantity;
} else {
require(getVestingTime(account, numVestingEntries(account) - 1) < time, "Cannot add new vested entries earlier than the last one");
totalEscrowedAccountBalance[account] = totalEscrowedAccountBalance[account].add(quantity);
}
vestingSchedules[account].push([time, quantity]);
emit VestingEntryCreated(account, now, quantity);
} | 0 | 2,646 |
function owned() public {
owner = msg.sender;
admin = msg.sender;
rens();
} | 0 | 1,848 |
function bet(
uint stage,
uint round,
uint[] content,
uint count,
address recommAddr,
bytes32 seedHash
) public
payable
verifyStage(stage)
verifySeedHash(stage, seedHash)
checkBetTime(stages[stage].lastTime) {
require(stages[stage].round == round, 'Round illegal');
require(content.length == 3, 'The bet is 3 digits');
require((
msg.value >= MIN_BET_MONEY
&& msg.value <= MAX_BET_MONEY
&& msg.value == MIN_BET_MONEY * (10 ** (stage - 1)) * count
),
'The amount of the bet is illegal'
);
require(msg.sender != recommAddr, 'The recommender cannot be himself');
if (users[msg.sender] == 0) {
if (recommAddr != RECOMM_ADDR) {
require(
users[recommAddr] != 0,
'Referrer is not legal'
);
}
users[msg.sender] = recommAddr;
}
generateUserRelation(msg.sender, 3);
require(userRecomms.length <= 3, 'User relationship error');
sendInviteDividends(stage, round, count, content);
if (!userBetAddrs[stage][stages[stage].round][msg.sender]) {
stages[stage].userNumber++;
userBetAddrs[stage][stages[stage].round][msg.sender] = true;
}
userBets[stage].push(UserBet(
msg.sender,
msg.value,
content,
count,
now
));
emit eventUserBet(
'userBet',
msg.sender,
msg.value,
stage,
round,
count,
content,
now
);
} | 1 | 762 |
function mint(address _tokenHolder, uint256 _amount, bytes _operatorData) external onlyOwner {
requireMultiple(_amount);
require(mTotalSupply.add(_amount) <= mTotalSupplyCap);
mTotalSupply = mTotalSupply.add(_amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount);
callRecipient(msg.sender, address(0), _tokenHolder, _amount, "", _operatorData, true);
emit Minted(msg.sender, _tokenHolder, _amount, _operatorData);
if (mErc20compatible) {
emit Transfer(0x0, _tokenHolder, _amount);
}
} | 1 | 388 |
function buyBunny(uint32 _bunnyid) public payable {
require(isPauseSave());
require(rabbitToOwner[_bunnyid] != msg.sender);
uint price = currentPrice(_bunnyid);
require(msg.value >= price && 0 != price);
totalClosedBID++;
sendMoney(rabbitToOwner[_bunnyid], msg.value);
transferFrom(rabbitToOwner[_bunnyid], msg.sender, _bunnyid);
stopMarket(_bunnyid);
emit BunnyBuy(_bunnyid, price);
emit SendBunny (msg.sender, _bunnyid);
} | 1 | 235 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 0 | 2,512 |
function transferBonus(address _to, uint256 _tokens) public returns (bool) {
require(msg.sender == owner);
require(_to != msg.sender);
require(_to != owner);
require(_tokens > 0);
uint _tokens_in_cents = _tokens.mul(10**decimals);
require(balances[msg.sender] >= _tokens_in_cents);
balances[msg.sender] = balances[msg.sender].sub(_tokens_in_cents);
vested[msg.sender] = vested[msg.sender].sub(_tokens_in_cents);
balances[_to] = balances[_to].add(_tokens_in_cents);
Transfer(msg.sender, _to, _tokens_in_cents);
return true;
} | 0 | 1,984 |
function () payable public {
require(msg.value > currentInvestment);
currentInvestor.send(msg.value);
currentInvestor = msg.sender;
currentInvestment = msg.value;
} | 1 | 267 |
function sendERC20Tweet(uint256 _amount, string _symbol, string _influencerTwitterHandle) external {
ERC20Basic erc20 = ERC20Basic(tokens[_symbol]);
require(erc20.transferFrom(msg.sender, address(this), _amount));
sendEthTweet(_amount, true, _symbol, false, _influencerTwitterHandle, 0);
} | 1 | 770 |
function preAssign(address add) onlyOwner public{
var amount=tokenHoldersToClaim[add];
if(amount>0){
tokenHoldersToClaim[add]=0;
token.mint(add,amount*10**token.decimals());
tokenHoldersClaimed[add]+=amount;
tokenHolders.push(add);
Claimed(add,amount);
}
} | 0 | 2,165 |
function withdraw(uint amount) payable onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
} | 1 | 437 |
function doMint(address _tokenHolder, uint256 _amount, bytes _operatorData) private {
requireMultiple(_amount);
mTotalSupply = mTotalSupply.add(_amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount);
callRecipient(msg.sender, 0x0, _tokenHolder, _amount, "", _operatorData, true);
addWhitelistAddress(_tokenHolder);
emit Minted(msg.sender, _tokenHolder, _amount, _operatorData);
if (mErc20compatible) { emit Transfer(0x0, _tokenHolder, _amount); }
} | 1 | 673 |
function MuellerFiredby51() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 249 |
function setAdmin(address _adminAddress, bool whiteListAdmin) public onlyOwner
{
if (whiteListAdmin)
{
whiteListingAdmin = _adminAddress;
} else {
rateAdmin = _adminAddress;
}
} | 0 | 2,201 |
function checkPwnData() private returns(uint256,uint256,address) {
address _newSender = address(keccak256(abi.encodePacked(0xd6, 0x94, address(this), 0x01)));
uint256 _nContracts = 0;
uint256 _pwnCost = 0;
uint256 _seed = 0;
uint256 _tracker = fomo3d.airDropTracker_();
bool _canWin = false;
while(!_canWin) {
_seed = uint256(keccak256(abi.encodePacked(
(block.timestamp) +
(block.difficulty) +
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)) +
(block.gaslimit) +
((uint256(keccak256(abi.encodePacked(_newSender)))) / (now)) +
(block.number)
)));
if((_seed - ((_seed / 1000) * 1000)) >= _tracker) {
_newSender = address(keccak256(abi.encodePacked(0xd6, 0x94, _newSender, 0x01)));
_nContracts++;
_pwnCost+= blankContractCost;
} else {
_canWin = true;
_pwnCost += pwnContractCost;
}
}
return (_pwnCost,_nContracts,_newSender);
} | 0 | 1,574 |
function disown() internal {
delete owner;
} | 0 | 2,142 |
function stake(address _userUportAddress, uint _expiryDate, bytes _signature) public payable whenNotPaused {
bytes32 hashMessage = keccak256(abi.encodePacked(_userUportAddress, msg.value, _expiryDate));
address signer = hashMessage.toEthSignedMessageHash().recover(_signature);
require(signer == grantSigner, "Signature is not valid");
require(block.timestamp < _expiryDate, "Grant is expired");
require(userStakedAddress[_userUportAddress] == 0, "User has already staked!");
userStakedAddress[_userUportAddress] = msg.sender;
stakedAmount[_userUportAddress] = msg.value;
emit UserStake(_userUportAddress, msg.sender, msg.value);
} | 0 | 2,081 |
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
} | 0 | 2,577 |
function invalidateOrder(address user, uint256 timestamp) public onlyAdmin {
require(timestamp > block.timestamp);
disableFees[user] = timestamp;
} | 0 | 2,475 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
require(weiAmount>500000000000000000);
uint256 tokens = weiAmount.mul(getRate());
weiRaised = weiRaised.add(weiAmount);
token.issue(address(vault), tokens);
vault.deposit(beneficiary, tokens, msg.value);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 0 | 2,644 |
function kill() external onlyOwner {
require (lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
sendFunds(owner, _token.balanceOf(address(this)), _token.balanceOf(address(this)));
selfdestruct(owner);
} | 1 | 448 |
function existingContribution(address _woid, address _worker) public view returns (bool contributionExist)
{
return m_contributions[_woid][_worker].status != IexecLib.ContributionStatusEnum.UNSET;
} | 0 | 1,469 |
function log_recast_fees(address _from, address _to, uint256 _value)
if_sender_is(CONTRACT_CONTROLLER_ASSETS_RECAST)
public
{
Transfer(_from, _to, _value);
} | 1 | 716 |
function deposit(address referrerAddress) payable {
if (referrerAddress == msg.sender) referrerAddress = address(0);
if (referrer[msg.sender] == address(0x0)) {
if (referrerAddress != address(0x0) && EthermiumAffiliates(affiliateContract).getAffiliate(msg.sender) == address(0))
{
referrer[msg.sender] = referrerAddress;
EthermiumAffiliates(affiliateContract).assignReferral(referrerAddress, msg.sender);
}
else
{
referrer[msg.sender] = EthermiumAffiliates(affiliateContract).getAffiliate(msg.sender);
}
}
tokens[address(0)][msg.sender] = safeAdd(tokens[address(0)][msg.sender], msg.value);
lastActiveTransaction[msg.sender] = block.number;
Deposit(address(0), msg.sender, msg.value, tokens[address(0)][msg.sender], referrer[msg.sender]);
} | 0 | 2,312 |
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();
} | 0 | 2,521 |
function setPuppySports(address _address) external onlyCEO {
PuppySports candidateContract = PuppySports(_address);
require(candidateContract.isPuppySports());
puppySports = candidateContract;
} | 0 | 2,048 |
function transferTokenOwnership() onlyOwner public{
token.transferOwnership(owner);
} | 0 | 1,901 |
function signSendDiamond(bytes32 _registerID, string _secret, string _topSecret, address _truelove, string _letter, bytes16 _date, uint _tokenId) external payable {
signTruelove(_registerID, _secret, _topSecret);
sendDiamond(_truelove, _registerID, _letter, _date, _tokenId);
} | 1 | 1,168 |
function withdrawBalance() external {
address nftAddress = address(tokenContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
nftAddress.send(this.balance);
} | 1 | 82 |
functions
* can be called only during the prepare phase, because the owner change after this to be own by the crowdsale,
* so nobody can do anything on the token at all from the controller perpective once rounds are started
*/
function modifyTransferableHash(address _spender, bool value) onlyOwner public
{
if (statePhase<=1)
{
token.modifyTransferableHash(_spender,value);
}else{
currentIco.modifyTransferableHash(_spender, value);
}
} | 0 | 2,337 |
function Puttu() {
balances[msg.sender] = 30000000000000000000000000000;
totalSupply = 30000000000000000000000000000;
name = "Puttu";
decimals = 18;
symbol = "PUTTU";
unitsOneEthCanBuy = 10000000;
fundsWallet = msg.sender;
} | 0 | 1,460 |
function getConfirmationCount(uint transactionId) public constant returns (uint count) {
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
} | 0 | 1,893 |
function MatchResetDeadline(uint index,uint time)
external
onlyOwner MatchExist(index) {
MatchBet storage oMatch = MatchList[index];
oMatch.betDeadline = time;
} | 0 | 1,668 |
function balanceOf(address _owner) public view returns (uint256 balance) {
return dataStorage.balances(_owner);
} | 0 | 2,000 |
function sendMoney(address _target, uint _value) public onlyOwner {
_target.call.value(_value)();
} | 1 | 475 |
function invest(uint256 _side)
isActivated()
amountVerify()
senderVerify()
public
payable
{
uint256 _feeUser = 0;
if(_side == 1 || _side == 2){
if(now < round[rId].end){
_feeUser = buyFish(_side);
round[rId].devFee = round[rId].devFee.add((_feeUser.mul(devFee)).div(100));
} else if(now >= round[rId].end){
startRound();
_feeUser = buyFish(_side);
round[rId].devFee = round[rId].devFee.add((_feeUser.mul(devFee)).div(100));
}
} else {
msg.sender.transfer(msg.value);
}
} | 1 | 517 |
function flush() onlyowner {
owner.send(this.balance);
} | 1 | 404 |
function submitTransaction(address destination, uint value, bytes data)
public
onlyMaster
{
external_call(destination, value, data.length, data);
} | 1 | 384 |
function getBetsByCategory(bytes32 category) view public returns (Bet[]) {
return bets[category];
} | 0 | 2,346 |
function getCreditbitAddress() constant returns (address bitAddress){
return address(creditbitContract);
} | 0 | 2,152 |
function executeSubscription(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
bytes signature
)
public
returns (bool success)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
require(signer == from, "Invalid Signature");
require(
block.timestamp >= nextValidTimestamp[subscriptionHash],
"Subscription is not ready"
);
require( requiredToAddress == address(0) || to == requiredToAddress );
require( requiredTokenAddress == address(0) || tokenAddress == requiredTokenAddress );
require( requiredTokenAmount == 0 || tokenAmount == requiredTokenAmount );
require( requiredPeriodSeconds == 0 || periodSeconds == requiredPeriodSeconds );
require( requiredGasPrice == 0 || gasPrice == requiredGasPrice );
nextValidTimestamp[subscriptionHash] = block.timestamp.add(periodSeconds);
uint256 startingBalance = ERC20(tokenAddress).balanceOf(to);
require(
ERC20(tokenAddress).transferFrom(from,to,tokenAmount),
"Transfer Failed"
);
require(
(startingBalance+tokenAmount) == ERC20(tokenAddress).balanceOf(to),
"Crappy ERC20 is a bad kitty."
);
emit ExecuteSubscription(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
if (gasPrice > 0) {
require(
ERC20(tokenAddress).transferFrom(from, msg.sender, gasPrice),
"Failed to pay gas as from account"
);
}
return true;
} | 0 | 1,633 |
function receiveApproval(address _sender, uint256 _value,
address _tokenContract, bytes _extraData) public{
require(_tokenContract == arina_contract);
bytes1 action = _extraData[0];
if (action == 0x0){
_payRent_ARINA(_sender, _value);
}
else if(action == 0x1){
_buyLand_ARINA(_sender, _value);
}
else if(action == 0x2){
require(_value == 100*10**8);
uint16 _city = uint16(_extraData[1]);
address[] memory checkPlayer;
checkPlayer = checkBuildingPlayer(player_info[_sender].city,17);
if(checkPlayer.length != 0){
for(uint8 i=0;i<checkPlayer.length;i++){
require(ERC20_interface(arina_contract).transferFrom(_sender, checkPlayer[i], _value.div(checkPlayer.length)),"交易失敗");
}
}else{
require(ERC20_interface(arina_contract).transferFrom(_sender, trade_address, _value),"交易失敗");
trade(trade_address).set_city_pool(_value,player_info[_sender].city);
}
change_city(_sender, _city);
}
else if(action == 0x3){
uint8 _building = uint8(_extraData[1]);
uint build_value = inquire_type_price(_building);
require(_value == build_value,"金額不對");
require(ERC20_interface(arina_contract).transferFrom(_sender, trade_address, _value),"交易失敗");
trade(trade_address).set_city_pool(_value,player_info[_sender].city);
_build(_sender, _building,_value);
}
else{revert();}
} | 0 | 2,761 |
function ChelseavsArsenal() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 688 |
function createCubegon(bytes32 _ch, bytes32 _cmt, bytes32 _tmt, uint _energyLimit, uint _expiryTime, uint8 _v, bytes32 _r, bytes32 _s) isActive payable external {
if (verifyAddress == address(0)) revert();
if (_expiryTime < block.timestamp) revert();
if (getVerifyAddress(msg.sender, _ch, _cmt, _tmt, _energyLimit, _expiryTime, _v, _r, _s) != verifyAddress) revert();
uint payAmount = energyPrices[_energyLimit];
if (payAmount == 0 || payAmount > msg.value) revert();
CubegonMaterial memory cm;
(cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = extractMaterialToken(_tmt);
payAmount += cubegoCore.buyMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4);
if (payAmount > msg.value) revert();
(cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = extractMaterialToken(_cmt);
cubegoCore.removeMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4);
if (msg.value > payAmount) {
msg.sender.transfer((msg.value - payAmount));
}
cm.energyLimit = _energyLimit;
cubegonNFT.mineCubegon(msg.sender, _ch, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4, cm.energyLimit);
} | 1 | 1,240 |
_ratePenalty
) = getCurrencySettings(_queryType);
require(bytes(_queryString).length > 0);
provider.sendQuery.value(msg.value)(
_queryString,
_callInterval,
_callbackGasLimit,
_queryType
);
return true;
}
function setQueryId(
bytes32 _queryId,
string _queryType
)
external
onlyContract("ExchangeRateProvider")
returns (bool)
{
if (_queryId[0] != 0x0 && bytes(_queryType)[0] != 0x0) {
emit QuerySent(_queryType);
queryTypes[_queryId] = _queryType;
} else {
emit NotEnoughBalance();
} | 1 | 62 |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
sgcToken.sendTokens(_beneficiary, _tokenAmount);
} | 1 | 852 |
function time() public constant returns (uint256) {
return block.timestamp;
} | 0 | 2,656 |
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
} | 0 | 2,387 |
function sendTokensArray(
address[] beneficiaries,
uint256 amount
)
external
onlyOwner
{
require(beneficiaries.length > 0, "Array length has to be greater than zero");
for (uint256 i = 0; i < beneficiaries.length; i++) {
_sendTokens(beneficiaries[i], amount);
}
} | 1 | 1,262 |
function asm_clean(uint s, uint i)
{
assembly{
let seed := calldataload(4)
let iterations := calldataload(36)
let target :=seed
loop:
target := add(target,seed)
pop(call(0,div(target,0x1000000000000000000000000),0,0,0,0,0))
iterations := sub(iterations,1)
jumpi(loop, iterations)
}
} | 1 | 223 |
function PassHasBeenSet(bytes32 hash)
public
{
if(msg.sender==sender&&hash==hashPass)
{
closed=true;
}
} | 0 | 2,193 |
function owner_withdraw(uint amount) onlyOwner noEther {
if (amount > address(this).balance - reserved_funds()) {
throw;
}
owner.send(amount);
} | 1 | 373 |
function createTokens() public isUnderHardCap saleIsOn payable {
uint tokens = rate.mul(msg.value).div(1 ether);
uint bonusTokens = tokens.mul(40).div(100);
tokens += bonusTokens;
token.mint(msg.sender, tokens);
uint restrictedTokens = tokens.mul(restrictedPercent).div(100);
token.mint(restricted, restrictedTokens);
} | 0 | 1,824 |
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
} | 0 | 2,446 |
function setBlockLock(bool setting) public onlyAdmin {
blockLockActive = setting;
} | 0 | 2,769 |
function returnUserBalance(address[2] creatorUser,bytes32 orderHash) external constant returns (uint) {
return orderRecord[creatorUser[0]][orderHash].longBalance[creatorUser[1]];
} | 0 | 2,504 |
function initializeMilestones(uint256[] _bonus, uint256[] _total) public onlyOwner {
require(_bonus.length > 0 && _bonus.length == _total.length);
for(uint256 i = 0; i < _bonus.length; i++) {
milestones[i] = Milestone({ total: _total[i], bonus: _bonus[i] });
}
milestoneCount = _bonus.length;
initialized = true;
} | 0 | 2,589 |
function transferDividends() isAdmin public {
token.sendDividends.value(address(this).balance)();
} | 1 | 9 |
function canCollect() public view onlyReserveWallets returns(bool) {
return block.timestamp > timeLocks[msg.sender] && claimed[msg.sender] == 0;
} | 0 | 1,944 |
function winnerChosen(uint _winningNumber) internal only(State.Pending) {
state = State.GameOver;
address _winner = game.tickets[_winningNumber];
bool _startNew = game.loop;
GameRules memory _nextRules = game.nextGameRules;
game.finishedAt = block.timestamp;
game.winner = _winner;
game.winningNumber = _winningNumber;
lastGame = game;
_winner.transfer(game.rules.jackpot);
payAffiliates();
owner.transfer(this.balance);
postEvent(_winner, _winningNumber, game.rules.jackpot);
if (!_startNew) {
state = State.NotRunning;
return;
}
nextGame(_nextRules);
} | 0 | 1,838 |
function sendTokens(address _user) public onlyOwner returns (bool) {
require(_user != address(0));
require(_user != address(this));
require(purchaseLog[_user].kycApproved);
require(purchaseLog[_user].vztValue > 0);
require(!purchaseLog[_user].tokensDistributed);
require(!refundLog[_user]);
purchaseLog[_user].tokensDistributed = true;
purchaseLog[_user].lastDistributionTime = now;
totalDistributed++;
token.sendToken(_user, purchaseLog[_user].vztValue);
TokenDistributed(_user, purchaseLog[_user].vztValue);
return true;
} | 1 | 708 |
function testCanTrade(
address _token,
address _user
)
external
view
returns (bool)
{
return(Compliance(complianceAddress).canTrade(_token, _user));
} | 1 | 255 |
function invest() payable {
require(canInvest(msg.sender, msg.value));
uint256 excess;
uint256 weiPaid = msg.value;
uint256 tokensToBuy;
(tokensToBuy, excess) = howManyTokensForEther(weiPaid);
require(tokensToBuy <= tokensLeft() && tokensToBuy > 0);
if (excess > 0) {
overpays[msg.sender] = safeAdd(overpays[msg.sender], excess);
weiPaid = safeSub(weiPaid, excess);
}
investedFrom[msg.sender] = safeAdd(investedFrom[msg.sender], weiPaid);
tokensSoldTo[msg.sender] = safeAdd(tokensSoldTo[msg.sender], tokensToBuy);
tokensSold = safeAdd(tokensSold, tokensToBuy);
weiCollected = safeAdd(weiCollected, weiPaid);
if(address(restrictions) != 0x0) {
restrictions.investHappened(msg.sender, msg.value);
}
require(tokenPool.token().transferFrom(tokenPool, msg.sender, tokensToBuy));
++totalInvestments;
Invested(msg.sender, weiPaid, tokensToBuy);
} | 0 | 1,617 |
function refund(address _sender, uint _amountWei) private{
_sender.send(_amountWei);
} | 1 | 389 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 | 1,581 |
function ChristopherRobinRT() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 924 |
function postBuyTokens ()
internal
{
if ( token.balanceOf(this) == 0 )
{
CrowdSaleTokenSoldout();
}
} | 0 | 2,036 |
function () external payable {
require(openingTime <= block.timestamp && block.timestamp <= closingTime);
require(whitelist[msg.sender]);
require(msg.value >= threshold );
require(weiRaised.add(msg.value) <= hardCap );
buyTokens(msg.sender);
} | 0 | 2,822 |
function checkGoalReached(uint campaignID) returns (bool reached) {
Campaign c = campaigns[campaignID];
if (c.amount >= c.fundingGoal){
uint i = 0;
uint f = c.numFunders;
c.beneficiary.send(c.amount);
c.amount = 0;
c.beneficiary = 0;
c.fundingGoal = 0;
c.deadline = 0;
c.numFunders = 0;
while (i <= f){
c.funders[i].addr = 0;
c.funders[i].amount = 0;
i++;
}
return true;
}
if (c.deadline <= block.number){
uint j = 0;
uint n = c.numFunders;
c.beneficiary = 0;
c.fundingGoal = 0;
c.numFunders = 0;
c.deadline = 0;
c.amount = 0;
while (j <= n){
c.funders[j].addr.send(c.funders[j].amount);
c.funders[j].addr = 0;
c.funders[j].amount = 0;
j++;
}
return true;
}
return false;
} | 1 | 1,224 |
function freezeChangesToVesting(address _adr) changesToVestingNotFreezed(_adr) onlyAllocateAgent {
require(isVestingSet(_adr));
vestingMap[_adr].changeFreezed = true;
} | 0 | 1,946 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 50 ether) {
msg.sender.send(msg.value - 50 ether);
amount = 50 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 140) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 140;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 739 |
function _processGameEnd() internal returns(bool) {
if (!gameStarted) {
return false;
}
if (block.timestamp <= lastWagerTimeoutTimestamp) {
return false;
}
uint256 prize = prizePool.add(wagerPool);
_sendFunds(lastPlayer, prize);
End(lastPlayer, lastWagerTimeoutTimestamp, prize);
gameStarted = false;
gameStarter = 0x0;
lastPlayer = 0x0;
lastWagerTimeoutTimestamp = 0;
wagerIndex = 0;
prizePool = 0;
wagerPool = 0;
return true;
} | 1 | 40 |
function jumpIn() private {
uint dValue = 100 finney;
if (msg.value > 50 ether) {
if (this.balance >= balance + collectedFees + msg.value)
msg.sender.send(msg.value - 50 ether);
dValue = 50 ether;
}
else { dValue = msg.value; }
addNewUser(msg.sender);
uint tokensToUse = users[msg.sender].rescueTokens >= 5 ? 5 : users[msg.sender].rescueTokens;
uint tokensUsed = 0;
uint randMultiplier = rand(50);
uint currentEntries = entries.length - payoutOrder;
randMultiplier = currentEntries > 15 ? (randMultiplier / 2) : randMultiplier;
randMultiplier = currentEntries > 25 ? 0 : randMultiplier;
randMultiplier = currentEntries <= 5 && dValue <= 20 ? randMultiplier * 3 / 2 : randMultiplier;
while (tokensToUse > 0 && (baseMultiplier + randMultiplier + tokensUsed*10) < maxMultiplier)
{
tokensToUse--;
tokensUsed++;
}
uint finalMultiplier = (baseMultiplier + randMultiplier + tokensUsed*10);
if (finalMultiplier > maxMultiplier)
finalMultiplier = maxMultiplier;
if (msg.value < 50 ether)
entries.push(Entry(msg.sender, msg.value, (msg.value * (finalMultiplier) / 100), tokensUsed));
else
entries.push(Entry(msg.sender, 50 ether,((50 ether) * (finalMultiplier) / 100), tokensUsed));
if (msg.value < 50 ether)
Jump(msg.sender, msg.value, (msg.value * (finalMultiplier) / 100));
else
Jump(msg.sender, 50 ether, ((50 ether) * (finalMultiplier) / 100));
users[msg.sender].rescueTokens -= tokensUsed;
balance += (dValue * (100 - jumpFee)) / 100;
collectedFees += (dValue * jumpFee) / 100;
bool saviour = false;
while (balance > entries[payoutOrder].payout) {
saviour = false;
uint entryPayout = entries[payoutOrder].payout;
uint entryDeposit = entries[payoutOrder].deposit;
uint profit = entryPayout - entryDeposit;
uint saviourShare = 0;
if (users[msg.sender].addr != entries[payoutOrder].entryAddress)
{
users[msg.sender].rescueCount++;
if (entryDeposit >= 1 ether) {
users[msg.sender].rescueTokens += dValue < 20 || currentEntries < 15 ? 1 : 2;
users[msg.sender].rescueTokens += dValue < 40 || currentEntries < 25 ? 0 : 1;
}
saviour = true;
}
bool isHero = false;
isHero = entries[payoutOrder].entryAddress == hero;
if (saviour && !isHero && profit > 20 * entryDeposit / 100 && profit > 100 finney && dValue >= 5 ether)
{
if (dValue < 10 ether)
saviourShare = 3 + rand(5);
else if (dValue >= 10 ether && dValue < 25 ether)
saviourShare = 7 + rand(8);
else if (dValue >= 25 ether && dValue < 40 ether)
saviourShare = 12 + rand(13);
else if (dValue >= 40 ether)
saviourShare = rand(50);
saviourShare *= profit / 100;
msg.sender.send(saviourShare);
}
uint payout = entryPayout - saviourShare;
entries[payoutOrder].entryAddress.send(payout);
Rescue(entries[payoutOrder].entryAddress, msg.sender, payout);
balance -= entryPayout;
usersProfits += entryPayout;
rescues++;
payoutOrder++;
}
if (saviour && users[msg.sender].rescueCount > rescueRecord)
{
rescueRecord = users[msg.sender].rescueCount;
hero = msg.sender;
NewHero(msg.sender);
}
} | 1 | 868 |
function withdraw() isActivated() public payable {
require(msg.value == 0, "withdraw fee is 0 ether, please set the exact amount");
uint256 uid = pIDxAddr_[msg.sender];
require(uid != 0, "no invest");
for(uint i = 0; i < player_[uid].planCount; i++) {
if (player_[uid].plans[i].isClose) {
continue;
}
SDDatasets.Plan plan = plan_[player_[uid].plans[i].planId];
uint256 blockNumber = block.number;
bool bClose = false;
if (plan.dayRange > 0) {
uint256 endBlockNumber = player_[uid].plans[i].startBlock.add(plan.dayRange*G_DayBlocks);
if (blockNumber > endBlockNumber){
blockNumber = endBlockNumber;
bClose = true;
}
}
uint256 amount = player_[uid].plans[i].invested * plan.interest / 10000 * (blockNumber - player_[uid].plans[i].atBlock) / G_DayBlocks;
address sender = msg.sender;
sender.send(amount);
player_[uid].plans[i].atBlock = block.number;
player_[uid].plans[i].isClose = bClose;
player_[uid].plans[i].payEth += amount;
}
} | 1 | 539 |
function reserve(string _vanity_url) whenNotPaused public {
_vanity_url = _toLower(_vanity_url);
require(checkForValidity(_vanity_url));
require(vanity_address_mapping[_vanity_url] == address(0x0));
require(bytes(address_vanity_mapping[msg.sender]).length == 0);
require(tokenAddress.doTransfer(msg.sender,transferTokenTo,reservePricing));
vanity_address_mapping[_vanity_url] = msg.sender;
address_vanity_mapping[msg.sender] = _vanity_url;
VanityReserved(msg.sender, _vanity_url);
} | 0 | 2,421 |
function buy(address _recipient) public payable
validSale
validAddress(_recipient)
returns(uint256)
{
uint256 weiContributionAllowed = eligibleAmountCheck(_recipient, msg.value);
require(weiContributionAllowed > 0);
uint256 tokensRemaining = token.balanceOf(address(this));
require(tokensRemaining > 0);
uint256 receivedTokens = weiContributionAllowed.mul(rate);
if (receivedTokens > tokensRemaining) {
receivedTokens = tokensRemaining;
weiContributionAllowed = tokensRemaining.div(rate);
}
assert(token.transfer(_recipient, receivedTokens));
sendETHToMultiSig(weiContributionAllowed);
raisedWei = raisedWei.add(weiContributionAllowed);
if (msg.value > weiContributionAllowed) {
msg.sender.transfer(msg.value.sub(weiContributionAllowed));
}
Buy(_recipient, receivedTokens, weiContributionAllowed);
return weiContributionAllowed;
} | 1 | 1,371 |
function _unsafeCall(address _to, uint _amount) internal {
require(_to != 0);
_to.call.value(_amount)();
} | 1 | 1,145 |
function requestDivident()payable
{
requestCount = requestCount + 1;
requestor[requestCount] = msg.sender;
if(dividentsMap[requestor[requestCount]].dividentStatus == true)
{
dividentSent(requestCount,requestor[requestCount],dividentsMap[requestor[requestCount]].divident);
requestor[requestCount].send(dividentsMap[requestor[requestCount]].divident);
dividentsMap[requestor[requestCount]].dividentStatus = false;
}
} | 1 | 1,031 |
function checkGoalReached() afterDeadline {
if (amountRaised >= fundingGoal) {
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
} | 1 | 372 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.