func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function () public payable {
assert(msg.value >= 1 ether);
uint256 time = now * 1000;
uint256 _value = msg.value.div(3);
uint256 tokens = currentRate.mul(_value);
token.transfer(msg.sender, tokens);
wallet.transfer(msg.value);
boughtTime[msg.sender] = time;
boughtUser[msg.sender][boughtTime[msg.sender]] = boughtUser[msg.sender][boughtTime[msg.sender]].add(msg.value.sub(_value));
claimAfter45ds[msg.sender] = false;
}
| 1 | 6,390 |
function MichiganvsLoyola() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 14,997 |
function distributeTax(
uint256 _fund,
uint256 _dividends,
uint256 _toRef,
uint256 _toPot)
private
{
addFund(_fund);
addDividends(_dividends);
addToRef(_toRef);
addToPot(_toPot);
}
| 1 | 8,203 |
function Studio () public {
totalSupply = maxSupply;
balances[msg.sender] = maxSupply;
STUDToEth = 1250000;
devWallet = msg.sender;
}
| 0 | 11,635 |
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
devFeeHandle(fee);
Token.transfer(msg.sender, SafeMath.sub(eggValue, fee));
}
| 1 | 7,648 |
function getRaisedEther() public view returns (uint256) {
if (fundraiseType == FundraiseType.ETH)
return fundsRaised;
else
return 0;
}
| 0 | 18,973 |
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){
purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE);
earlyPurchases.push(EarlyPurchase(purchaser, WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised, purchasedAt));
totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised;
}
else{
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
totalEarlyPurchaseRaised += amount;
}
if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE || now >= ENDING_TIME){
earlyPurchaseClosedAt = now;
}
return true;
}
| 0 | 18,747 |
function challenge(bytes32 _listingHash, string _data) external returns (uint challengeID) {
Listing storage listing = listings[_listingHash];
uint deposit = parameterizer.get("minDeposit");
require(appWasMade(_listingHash) || listing.whitelisted);
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
if (listing.unstakedDeposit < deposit) {
resetListing(_listingHash);
_TouchAndRemoved(_listingHash);
return 0;
}
uint pollID = voting.startPoll(
parameterizer.get("voteQuorum"),
parameterizer.get("commitStageLen"),
parameterizer.get("revealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: ((100 - parameterizer.get("dispensationPct")) * deposit) / 100,
stake: deposit,
resolved: false,
totalTokens: 0
});
listing.challengeID = pollID;
listing.unstakedDeposit -= deposit;
require(token.transferFrom(msg.sender, this, deposit));
var (commitEndDate, revealEndDate,) = voting.pollMap(pollID);
_Challenge(_listingHash, pollID, _data, commitEndDate, revealEndDate, msg.sender);
return pollID;
}
| 1 | 1,965 |
function release(address _addr) external {
require(owners[msg.sender] || msg.sender == _addr);
require(block.timestamp >= releaseTimestamps[_addr]);
uint256 amount = lockAmounts[_addr];
lockAmounts[_addr] = 0;
releaseTimestamps[_addr] = 0;
token.transfer(_addr, amount);
}
| 0 | 11,743 |
function internally generates the correct oraclize_query and returns its queryId
uint256 potentialRevenue = StakeDiceGame(msg.sender).multiplierOnWin() * _amount / 10000;
BetPlaced(_gambler, bets.length);
oraclizeQueryIdsToBetIndices[queryId] = bets.length;
playersToBetIndices[_gambler].push(bets.length);
bets.push(Bet({gambler: _gambler, winningChance: _winningChance, betAmount: _amount, potentialRevenue: potentialRevenue, roll: 0, status: BetStatus.IN_PROGRESS}
| 1 | 7,667 |
function safeWithdrawal(address _receiver, uint256 _value) public {
require((msg.sender == _owner));
uint256 valueAsEth = mul(_value,1 ether);
if(_payFees) _devFeesAddr.transfer(_devFees);
require(valueAsEth <= this.balance);
_receiver.transfer(valueAsEth);
}
| 0 | 15,513 |
function() payable {
if(msg.value <= min_value) throw;
if(msg.value >= max_value) throw;
if(now < contract_start) throw;
if(now > contract_finish) throw;
if(cap + msg.value > cap_max) throw;
tokens_total = msg.value*10**18/token_price;
if(!(tokens_total > 0)) throw;
if(!contract_transfer(tokens_total)) throw;
cap = cap.add(msg.value);
operations();
get_card();
}
| 1 | 1,584 |
function registerModule(address _moduleFactory) external whenNotPaused returns(bool) {
require(registry[_moduleFactory] == 0, "Module factory should not be pre-registered");
IModuleFactory moduleFactory = IModuleFactory(_moduleFactory);
require(moduleFactory.getType() != 0, "Factory type should not equal to 0");
registry[_moduleFactory] = moduleFactory.getType();
moduleList[moduleFactory.getType()].push(_moduleFactory);
reputation[_moduleFactory] = new address[](0);
emit LogModuleRegistered (_moduleFactory, moduleFactory.owner());
return true;
}
| 1 | 2,025 |
function deposit(address _beneficiary, address[] _tokens, uint256[] _tokenValues) payable external {
if (msg.value > 0) {
balances[_beneficiary] = balances[_beneficiary].add(msg.value);
}
for (uint i = 0; i < _tokens.length; i++) {
ERC20 token = ERC20(_tokens[i]);
uint256 tokenValue = _tokenValues[i];
uint256 balance = token.balanceOf(this);
token.transferFrom(msg.sender, this, tokenValue);
require(token.balanceOf(this) == balance.add(tokenValue));
tokenBalances[_beneficiary][token] = tokenBalances[_beneficiary][token].add(tokenValue);
}
}
| 1 | 6,625 |
function buyCoinsAtICO() payable public returns(bool success) {
msgSndr[msg.sender] = msg.value;
ICO ico = ICO(_getIcoAddr() );
require( msg.value > 0 );
bool icosuccess; uint tknsBuyAppr;
(icosuccess, tknsBuyAppr) = ico.buy( msg.value, msg.sender, false);
require( icosuccess == true );
bool sucsTrTk = _safeTransferTkn( owner, msg.sender, tknsBuyAppr);
require(sucsTrTk == true);
msgSndr[msg.sender] = 0;
return (true) ;
}
| 1 | 5,886 |
function sendEthTweet(uint256 _amount, bool _isERC20, string _symbol, bool _payFromMsg, string _followerTwitterHandle, string _influencerTwitterHandle, string _tweet) private {
require(
(!_isERC20 && _payFromMsg && msg.value == _amount) ||
(!_isERC20 && !_payFromMsg && _amount <= address(this).balance) ||
_isERC20
);
ERC20Basic erc20;
if (_isERC20) {
require(tokens[_symbol] != 0x0);
erc20 = ERC20Basic(tokens[_symbol]);
require(erc20.balanceOf(address(this)) >= _amount);
}
Influencer memory influencer = influencers[_influencerTwitterHandle];
require(influencer.influencerAddress != 0x0);
uint256[] memory payouts = new uint256[](4);
payouts[3] = 100;
if (influencer.charityPercentage == 0) {
payouts[0] = _amount.mul(payouts[3].sub(feePercentage)).div(payouts[3]);
payouts[2] = _amount.sub(payouts[0]);
} else {
payouts[1] = _amount.mul(influencer.charityPercentage).div(payouts[3]);
payouts[0] = _amount.sub(payouts[1]).mul(payouts[3].sub(feePercentage)).div(payouts[3]);
payouts[2] = _amount.sub(payouts[1]).sub(payouts[0]);
}
require(payouts[0].add(payouts[1]).add(payouts[2]) == _amount);
ethTweets.push(EthTweet(_followerTwitterHandle, _influencerTwitterHandle, _tweet, _amount, _symbol));
emit EthTweetSent(
_followerTwitterHandle,
_influencerTwitterHandle,
_amount,
_symbol,
ethTweets.length - 1
);
if (payouts[0] > 0) {
if (!_isERC20) {
influencer.influencerAddress.transfer(payouts[0]);
} else {
erc20.transfer(influencer.influencerAddress, payouts[0]);
}
emit Payment(influencer.influencerAddress, payouts[0], _symbol);
}
if (payouts[1] > 0) {
if (!_isERC20) {
influencer.charityAddress.transfer(payouts[1]);
} else {
erc20.transfer(influencer.charityAddress, payouts[1]);
}
emit Payment(influencer.charityAddress, payouts[1], _symbol);
}
if (payouts[2] > 0) {
if (!_isERC20) {
if (webappAddress.balance < webappMinBalance) {
webappAddress.transfer(payouts[2].div(5));
payouts[2] = payouts[2].sub(payouts[2].div(5));
emit Payment(webappAddress, payouts[2].div(5), _symbol);
}
feePayoutAddress.transfer(payouts[2]);
} else {
erc20.transfer(feePayoutAddress, payouts[2]);
}
emit Payment(feePayoutAddress, payouts[2], _symbol);
}
}
| 1 | 6,281 |
function finishMinting() public onlyOwner returns(bool){
require(hasEnded());
uint256 deltaBonusTokens = tokensSold-weiRaised*rate;
uint256 bonusTokens = weiRaised*maxBonusRate*rate/100-deltaBonusTokens;
token.mint(bonusWallet,bonusTokens);
uint256 preICOTokens = weiRaisedInPresale*3000;
token.mint(bonusWallet,preICOTokens);
uint issuedTokenSupply = token.totalSupply();
uint restrictedTokens = (issuedTokenSupply-tokensGranted)*40/60-tokensGranted;
if(restrictedTokens>0){
token.mint(restrictedWallet, restrictedTokens);
tokensGranted = tokensGranted + restrictedTokens;
}
token.finishMinting();
token.transferOwnership(owner);
MainSaleClosed();
return true;
}
| 1 | 1,215 |
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
| 0 | 18,761 |
function getVested(address _beneficiary) public returns (uint256) {
require(balances[_beneficiary]>0);
if (_beneficiary == owner){
vested[owner] = balances[owner];
total_vested[owner] = balances[owner];
} else if (block.timestamp < start) {
vested[_beneficiary] = 0;
total_vested[_beneficiary] = 0;
} else if (block.timestamp >= start.add(duration)) {
total_vested[_beneficiary] = balances[_beneficiary];
vested[_beneficiary] = balances[_beneficiary];
} else {
uint vested_now = balances[_beneficiary].mul(block.timestamp.sub(start)).div(duration);
if(total_vested[_beneficiary]==0){
total_vested[_beneficiary] = vested_now;
}
if(vested_now > total_vested[_beneficiary]){
vested[_beneficiary] = vested[_beneficiary].add(vested_now.sub(total_vested[_beneficiary]));
total_vested[_beneficiary] = vested_now;
}
}
return vested[_beneficiary];
}
| 0 | 13,093 |
function roll(uint16[] territories,uint16 team)
payable
public
{
RequireHuman();
require(isactive);
require(team!=0);
uint256 _rID = roundID;
uint256 _now = block.timestamp;
uint256 _roundstart = Rounds[_rID].roundstart;
uint256 _trucetime = Rounds[_rID].trucetime;
if (Rounds[_rID].teamXaddr[msg.sender]==0){
Rounds[_rID].teamXaddr[msg.sender]=team;
}
else{
require(Rounds[_rID].teamXaddr[msg.sender]==team);
}
require(msg.value==Rounds[_rID].price );
uint16 _maxroll = Rounds[_rID].maxroll;
seed = uint256(keccak256(abi.encodePacked((seed^block.timestamp))));
uint256 rolled = (seed % _maxroll)+1;
uint256 validrolls=0;
uint16[] memory territoriesconquered = new uint16[](_maxroll);
if (_roundstart+_trucetime<_now){
for (uint i = 0 ; i<territories.length;i++){
if (getownership(territories[i])==team){
continue;
}
if (hasteamadjacency(territories[i],team)){
territoriesconquered[validrolls]=territories[i];
setownership(territories[i],team);
validrolls+=1;
if (validrolls==rolled){
break;
}
}
}
}
else{
require(Rounds[_rID].validrollsXteam[team]<Rounds[_rID].maxextensiontruce);
for (i = 0 ; i<territories.length;i++){
if (getownership(territories[i])!=0){
continue;
}
if (hasteamadjacency(territories[i],team)){
territoriesconquered[validrolls]=territories[i];
setownership(territories[i],team);
validrolls+=1;
if (validrolls==rolled){
break;
}
}
}
}
Rounds[_rID].validrollsXaddr[msg.sender]+=validrolls;
Rounds[_rID].validrollsXteam[team]+=validrolls;
uint256 refund;
if (validrolls<rolled){
refund = ((rolled-validrolls)*msg.value)/rolled;
}
Rounds[_rID].pot+=msg.value-refund;
if (refund>0){
msg.sender.transfer(refund);
}
emit onroll(
nameXaddress[msg.sender],
Rounds[_rID].nationnameXteam[team],
rolled,
team,
territoriesconquered,
msg.sender
);
}
| 0 | 19,399 |
function finalize() public initialized {
require(getBlockNumber() >= startBlock);
require(msg.sender == owner || getBlockNumber() > endBlock);
require(finalizedBlock == 0);
require(dynamicCeiling.allRevealed());
if (getBlockNumber() <= endBlock) {
var (,lastLimit,,) = dynamicCeiling.curves(dynamicCeiling.revealedCurves().sub(1));
require(totalNormalCollected >= lastLimit);
}
finalizedBlock = getBlockNumber();
finalizedTime = now;
uint256 percentageToSgt;
if (SGT.totalSupply() >= maxSGTSupply) {
percentageToSgt = percent(10);
} else {
percentageToSgt = percent(10).mul(SGT.totalSupply()).div(maxSGTSupply);
}
uint256 percentageToDevs = percent(20);
uint256 percentageToContributors = percent(41).add(percent(10).sub(percentageToSgt));
uint256 percentageToReserve = percent(29);
uint256 totalTokens = SNT.totalSupply().mul(percent(100)).div(percentageToContributors);
assert(SNT.generateTokens(
destTokensReserve,
totalTokens.mul(percentageToReserve).div(percent(100))));
assert(SNT.generateTokens(
destTokensSgt,
totalTokens.mul(percentageToSgt).div(percent(100))));
assert(SNT.generateTokens(
destTokensDevs,
totalTokens.mul(percentageToDevs).div(percent(100))));
SNT.changeController(sntController);
Finalized();
}
| 1 | 9,276 |
function close() public onlyOwner {
require(state == State.Active);
state = State.Closed;
emit Closed();
}
| 0 | 17,562 |
function initProposalVoting(uint256 _proposalId) internal {
ResultRecord storage result = ResultsByProposalId[_proposalId];
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(getApplicationState() == getApplicationEntityState("IN_DEVELOPMENT") ) {
if(proposal.actionType == getActionType("PROJECT_DELISTING") ) {
uint256 ownerLockedTokens = TokenEntity.balanceOf(TokenManagerEntity);
result.totalAvailable = TokenEntity.totalSupply() - ownerLockedTokens;
result.requiresCounting = true;
} else {
result.totalAvailable = FundingManagerEntity.LockedVotingTokens();
result.requiresCounting = false;
}
} else if(getApplicationState() == getApplicationEntityState("DEVELOPMENT_COMPLETE") ) {
uint256 residualLockedTokens = TokenEntity.balanceOf(TokenManagerEntity);
result.totalAvailable = TokenEntity.totalSupply() - residualLockedTokens;
result.requiresCounting = true;
}
result.requiredForResult = result.totalAvailable / 2;
proposal.state = getRecordState("ACCEPTING_VOTES");
addActiveProposal(_proposalId);
tryFinaliseNonLockedTokensProposal(_proposalId);
}
| 1 | 31 |
function completeUnlock(
bytes32 _requestMsgHash,
uint8 _recoveryByte1, bytes32 _ecdsaR1, bytes32 _ecdsaS1,
uint8 _recoveryByte2, bytes32 _ecdsaR2, bytes32 _ecdsaS2
)
public
returns (bool success)
{
Request storage request = requestMap[_requestMsgHash];
bytes32 lockId = request.lockId;
address callbackAddress = request.callbackAddress;
bytes4 callbackSelector = request.callbackSelector;
require(callbackAddress != address(0));
require(request.idx > lastCompletedIdxs[callbackAddress][callbackSelector]);
address signer1 = ecrecover(_requestMsgHash, _recoveryByte1, _ecdsaR1, _ecdsaS1);
require(signerSet[signer1]);
address signer2 = ecrecover(_requestMsgHash, _recoveryByte2, _ecdsaR2, _ecdsaS2);
require(signerSet[signer2]);
require(signer1 != signer2);
if (request.extended && ((block.timestamp - request.timestamp) < extendedTimeLock)) {
emit TimeLocked(request.timestamp + extendedTimeLock, _requestMsgHash);
return false;
} else if ((block.timestamp - request.timestamp) < defaultTimeLock) {
emit TimeLocked(request.timestamp + defaultTimeLock, _requestMsgHash);
return false;
} else {
if (address(this).balance > 0) {
success = msg.sender.send(address(this).balance);
}
lastCompletedIdxs[callbackAddress][callbackSelector] = request.idx;
delete requestMap[_requestMsgHash];
success = callbackAddress.call(callbackSelector, lockId);
if (success) {
emit Completed(lockId, _requestMsgHash, signer1, signer2);
} else {
emit Failed(lockId, _requestMsgHash, signer1, signer2);
}
}
}
| 0 | 13,784 |
function buyGold(uint256 _GoldPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_GoldPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _GoldPrice);
assert(ndc.transfer(msg.sender, GOLD_AMOUNT_NDC)
&& tpt.transfer(msg.sender, GOLD_AMOUNT_TPT)
&& skl.transfer(msg.sender, GOLD_AMOUNT_SKL)
&& xper.transfer(msg.sender, GOLD_AMOUNT_XPER));
emit BuyGold(msg.sender, _GoldPrice, msg.value);
}
| 0 | 14,147 |
function buildDown(uint _x, uint _y, uint _length) private
{
require(0x0 == owners[_x][_y][1]);
KingOfEthHousesAbstractInterface _housesContract = KingOfEthHousesAbstractInterface(housesContract);
address _houseOwner = _housesContract.ownerOf(_x, _y);
require(_houseOwner == msg.sender || (0x0 == _houseOwner && (
owners[_x][_y][0] == msg.sender
|| owners[_x - 1][_y][0] == msg.sender
|| owners[_x][_y - 1][1] == msg.sender
)));
owners[_x][_y][1] = msg.sender;
for(uint _i = 1; _i < _length; ++_i)
{
require(0x0 == owners[_x][_y + _i][1]);
require(
_housesContract.ownerOf(_x, _y + _i) == 0x0
|| _housesContract.ownerOf(_x, _y + _i) == msg.sender
);
owners[_x][_y + _i][1] = msg.sender;
}
}
| 1 | 3,585 |
function endRound(PCKdatasets.EventReturns memory _eventData_)
private
returns (PCKdatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_com.add(_p3d.sub(_p3d / 2)));
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_res = _res.add(_p3d / 2);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.PCPAmount = _p3d;
_eventData_.newPot = _res;
_rID++;
round_[_rID].ended = false;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 0 | 15,922 |
function vestedAmount(ERC20Basic _token) public view returns (uint256) {
uint256 currentBalance = _token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(released[_token]);
require(chunks < 100);
if (block.timestamp < start) {
return 0;
}
for (uint i=0; i<chunks; i++) {
if (block.timestamp > start.add(period.mul(i)) && block.timestamp <= start.add(period.mul(i+1))) {
return totalBalance.div(chunks).mul(i+1);
}
}
return 0;
}
| 0 | 18,952 |
function that can
function cancelAuction(uint256 _tokenId)
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
address seller = auction.seller;
require(msg.sender == seller);
_cancelAuction(_tokenId, seller);
}
| 1 | 7,541 |
function payInternal(address _buyer, address _seller, uint _amount, address _opinionLeader) internal {
require(balances[_buyer] >= _amount);
uint fee;
if (cryptaurRewards != 0 && cryptaurReserveFund != 0) {
fee = CryptaurRewards(cryptaurRewards).payment(_buyer, _seller, _amount, _opinionLeader);
}
balances[_buyer] -= _amount;
balances[_seller] += _amount - fee;
if (fee != 0) {
balances[cryptaurReserveFund] += fee;
CryputarReserveFund(cryptaurReserveFund).depositNotification(_amount);
}
Payment(_buyer, _seller, _amount, _opinionLeader, false);
}
| 1 | 6,909 |
function startMarket(uint32 _bunnyId, uint _money) public returns (uint) {
require(checkContract());
require(isPauseSave());
require(_money >= reallyPrice);
require(publicContract.ownerOf(_bunnyId) == msg.sender);
bunnyCost[_bunnyId] = _money;
timeCost[_bunnyId] = block.timestamp;
emit StartMarket(_bunnyId, currentPrice(_bunnyId), block.timestamp, stepTimeSale);
return marketCount++;
}
| 1 | 2,928 |
function _deposit(
address _token,
address _from,
uint _tokens,
bytes _data
) private returns (bool success) {
ERC20Interface(_token).transferFrom(
_from, address(this), _tokens);
address receiver = 0x0;
if (_data.length == 20) {
receiver = _bytesToAddress(_data);
} else {
receiver = _from;
}
_balances[_token][receiver] =
_balances[_token][receiver].add(_tokens);
emit Deposit(_token, receiver, _tokens, _data);
return true;
}
| 1 | 3,208 |
function distributePresaleTokens(address[] _buyers, uint[] _amounts)
public
onlyOwner
saleNotEnded
{
assert(!setupCompleteFlag);
require(_buyers.length < 11);
require(_buyers.length == _amounts.length);
for(uint i=0; i < _buyers.length; i++){
require(SafeMath.add(privateAllocated, _amounts[i]) <= MAX_PRIVATE);
assert(token.transfer(_buyers[i], _amounts[i]));
privateAllocated = SafeMath.add(privateAllocated, _amounts[i]);
PurchasedTokens(_buyers[i], _amounts[i]);
}
assert(token.balanceOf(this) >= (SafeMath.sub(TOTAL_SUPPLY, MAX_PRIVATE)));
}
| 1 | 4,072 |
function release() public {
require(!revoked);
uint256 grant;
uint percent;
for (uint32 i = 0; i < vestingCommencementDates.length; i++) {
if (block.timestamp < vestingCommencementDates[i]) {
} else {
percent += vestingPercents[i];
}
}
grant = total.mul(percent).div(100);
if (grant > lapsedTotal) {
uint256 tokens = grant.sub(lapsedTotal);
lapsedTotal = lapsedTotal.add(tokens);
if (!token.transfer(account, tokens)) {
revert();
} else {
}
}
}
| 0 | 15,966 |
function createTeam(string _name, string _logo, uint256 _minTalent, uint256 _minSkills, address _owner, uint256 _playerId) public onlyCOO returns(uint256 _teamId) {
_teamId = teamsIds.length + 1;
PlayerToken playerToken = PlayerToken(playerTokenAddress);
uint256 _position = playerToken.getPosition(_playerId);
teams[_teamId].name = _name;
teams[_teamId].minSkills = _minSkills;
teams[_teamId].minTalent = _minTalent;
teams[_teamId].logo = _logo;
teamsIds.push(_teamId);
_addOwnerPlayerToTeam(_teamId, _owner, _playerId, _position);
}
| 1 | 1,343 |
function recoverAddr(bytes32 hash, bytes sig) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 33))
s := mload(add(sig, 65))
v := mload(add(sig, 1))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(1));
} else {
return ecrecover(hash, v, r, s);
}
}
| 0 | 15,554 |
function () public payable stopInEmergency beforeDeadline ICOactive{
require(msg.value >= MinimumInvestment());
uint amount = amountToSend(msg.value);
if (amount==0){
revert();
}else{
balanceOf[msg.sender] += msg.value;
amountRaised += msg.value;
tokenReward.transfer(msg.sender,amount);
tokensSold = add(tokensSold,amount);
ReceivedETH(msg.sender,msg.value);
}
}
| 1 | 7,026 |
function numQuestions() public view returns (uint) {
return questions.size();
}
| 0 | 13,494 |
function today() public constant returns (uint) {
return time() / 24 hours;
}
| 1 | 5,117 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, H3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
else
updateGenVault(_pID, plyr_[_pID].lrnd);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _keys, _eventData_);
internalNoter(_rID, _pID);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 8,596 |
function totally_decrease_the_supply(uint256 amount_to_burn_from_supply) public payable {
require(balances[msg.sender] >= amount_to_burn_from_supply);
balances[msg.sender] = balances[msg.sender].sub(amount_to_burn_from_supply);
totalSupply = totalSupply.sub(amount_to_burn_from_supply);
}
| 0 | 14,797 |
function _powerTwo(
string result,
uint256 pnOne,
uint256 pnTwo,
address playerAddress
) internal {
require(pnOne != 0, "Invalid game, refunded!");
require(pnTwo != 0, "Invalid game, refunded!");
require(powerTwoJackpot <= address(this).balance, "Insufficient funds!");
strings.slice memory res = result.toSlice();
strings.slice memory delim = " ".toSlice();
uint256[] memory parts = new uint256[](res.count(delim) + 1);
for (uint256 i = 0; i < parts.length; i ++) {
parts[i] = parseInt(res.split(delim).toString());
}
if (bytes(result).length == 0) {
emit Refund(
playerAddress,
1
);
if (!playerAddress.send(SafeMath.add(powerTwoBid, powerTwoFee))) {
playerFundsToWithdraw[playerAddress] = SafeMath.add(powerTwoBid, powerTwoFee);
}
playerAddress = 0x0;
return;
}
if (_checkTwo(
parts[1],
parts[2],
pnOne,
pnTwo)) {
if(_checkMegaJackpotCap(playerAddress)) {
bool checkResult = true;
} else {
checkResult = false;
}
powerTwoWinCounter ++;
uint256 eligiblePayout = SafeMath.div(SafeMath.mul(powerTwoJackpot, platformCut), 100);
uint256 platformCutPayout = SafeMath.sub(powerTwoJackpot, eligiblePayout);
playerAddress.transfer(SafeMath.div(SafeMath.mul(powerTwoJackpot, platformCut), 100));
ceoAddress.transfer(platformCutPayout);
emit PowerEtherResults(
playerAddress,
parts[0],
2,
pnOne,
pnTwo,
0,
0,
eligiblePayout,
true,
checkResult
);
totalEtherWon += eligiblePayout;
powerTwoJackpot = 0;
playerAddress = 0x0;
} else if (!_checkTwo(
parts[1],
parts[2],
pnOne,
pnTwo)) {
emit PowerEtherResults(
playerAddress,
parts[0],
2,
pnOne,
pnTwo,
0,
0,
eligiblePayout,
false,
false
);
playerAddress = 0x0;
}
}
| 1 | 5,667 |
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);
}
| 0 | 11,550 |
function reclaimEther() external onlyOwner {
owner.transfer(this.balance);
}
| 0 | 13,853 |
function transferFrom(address _from, address _to, uint _amount) public returns (bool success) {
require(isTransferable());
require(locked[_from] == false);
require(locked[_to] == false);
return super.transferFrom(_from, _to, _amount);
}
| 0 | 12,084 |
function claimProduct(address _productAddress,uint _quantity) external payable brandOwnerOnly(_productAddress) {
require(totalAllowedProducts[_productAddress] == 0 || totalAllowedProducts[_productAddress] >= totalMintedProducts[_productAddress] + _quantity);
address productBrandAddress;
address appAccountAddress;
address appFeeAccount;
address deveryFeeAccount;
uint appFee;
uint deveryFee;
(,productBrandAddress,,,,,) = deveryRegistry.products(_productAddress);
(,appAccountAddress,,) = deveryRegistry.brands(productBrandAddress);
(,,appFeeAccount,appFee,) = deveryRegistry.apps(appAccountAddress);
deveryFee = deveryRegistry.fee();
deveryFeeAccount = deveryRegistry.feeAccount();
if (appFee > 0) {
token.transferFrom(productBrandAddress, appFeeAccount, appFee*_quantity);
}
if (deveryFee > 0) {
token.transferFrom(productBrandAddress, deveryFeeAccount, deveryFee*_quantity);
}
for(uint i = 0;i<_quantity;i++){
uint nextId = tokenIdToProduct.push(_productAddress) - 1;
_mint(msg.sender,nextId);
}
totalMintedProducts[_productAddress]+=_quantity;
}
| 1 | 2,930 |
function getValidatorDescription(
address validator
) external view returns (
string description
) {
return _validators[validator].description;
}
| 0 | 18,681 |
function registered(string _playerName)
senderVerify()
registerVerify()
payable
public
{
bytes32 _name = _playerName.nameFilter();
require(_name != bytes32(0), "name cannot be empty");
require(playerName[_name] == address(0), "this name has already been registered");
require(register[msg.sender] == bytes32(0), "please do not repeat registration");
playerName[_name] = msg.sender;
register[msg.sender] = _name;
developerAddr.send(msg.value);
}
| 0 | 11,893 |
function __callback(bytes32 _myid, string memory _result) public {
__callback(_myid, _result, new bytes(0));
}
| 0 | 14,778 |
function assignOperator(address user_)
public
onlyOwner
{
if(user_ != address(0) && !authbook[user_]) {
authbook[user_] = true;
operators.push(user_);
}
}
| 0 | 16,033 |
function calcTokens(uint256 stage, uint256 amountContributed, uint256 raisedAt) internal returns (int256){
int256 T = int256(stages[stage].tokensRaised);
int256 L = int256(stages[stage].lowerBound);
int256 U = int256(stages[stage].upperBound);
int256 a=((U-L)/2);
int256 b = 0;
if(raisedAt > 0){
b=(L*T+(calcTokens(stage,raisedAt,0)*(U-L))-a);
}else{
b=(L*T+(0*(U-L))-a);
}
assert(b != 0);
int256 c=-(int256(amountContributed)*10**18)*T;
return ((-b+sqrt(b*b-4*a*c))/(2*a))+1;
}
| 1 | 7,150 |
function order_buy(address _from, uint256 _max_price) payable returns (bool) {
require(msg.value > 0);
require(_max_price > 0);
require(orders_sell_amount[_from] > 0);
require(orders_sell_price[_from] > 0);
require(orders_sell_price[_from] <= _max_price);
uint _amount = (msg.value*10**18).div(orders_sell_price[_from]);
uint _amount_from = get_orders_sell_amount(_from);
if(_amount > _amount_from) _amount = _amount_from;
require(_amount > 0);
uint _total_money = (orders_sell_price[_from]*_amount).div(10**18);
require(_total_money <= msg.value);
uint _seller_money = (_total_money*100).div(coef);
uint _buyer_money = msg.value - _total_money;
require(_seller_money > 0);
require(_seller_money + _buyer_money <= msg.value);
_from.send(_seller_money);
msg.sender.send(_buyer_money);
orders_sell_amount[_from] -= _amount;
balances[_from] -= _amount;
balances[msg.sender] += _amount;
Orders_sell(_from, msg.sender, _amount, orders_sell_price[_from], _seller_money, _buyer_money);
}
| 0 | 19,211 |
function listSpriteForSale (uint spriteId, uint price) {
require (price > 0);
if (broughtSprites[spriteId].owner != msg.sender) {
require (broughtSprites[spriteId].timesTraded == 0);
var (kittyOwner,,,,) = SaleClockAuction(SaleClockAuctionAddress).getAuction(spriteId);
if (kittyOwner != msg.sender) {
address kittyOwnerNotForSale = KittyCore(KittyCoreAddress).ownerOf(spriteId);
require (kittyOwnerNotForSale == msg.sender);
}
broughtSprites[spriteId].owner = msg.sender;
broughtSprites[spriteId].spriteImageID = uint(block.blockhash(block.number-1))%360 + 1;
}
broughtSprites[spriteId].forSale = true;
broughtSprites[spriteId].price = price;
}
| 1 | 1,593 |
function GetPlayerInfo() external view returns(
bool bCanSignIn,
uint allBonus,
uint myBonus,
uint32[] stuffIdxList,
uint[] stuffNumList,
uint32[] tempStuffList,
uint[] tempStuffTime
)
{
(bCanSignIn,,) = CanSignIn();
allBonus = g_Main.QueryBonus();
myBonus = g_Main.QueryMyBonus(msg.sender);
(stuffIdxList,stuffNumList) = g_Main.GetStuffList(msg.sender);
(tempStuffList,tempStuffTime) = g_Main.GetTempStuffList(msg.sender);
}
| 1 | 6,462 |
function () external payable {
Investor storage investor = investors[msg.sender];
if (msg.value > 0){
require(!startOfPayments);
if (msg.sender != DPAddress && msg.value >= 0.1 ether) {
require(countOfInvestors.add(1) <= DPContract.countOfInvestors().mul(32).div(100));
uint256 deposit;
uint256 withdrawals;
(deposit, withdrawals, investor.insured) = DPContract.setInsured(msg.sender);
require(msg.value >= deposit.div(10) && deposit > 0);
if (msg.value > deposit.div(10)) {
msg.sender.transfer(msg.value - deposit.div(10));
}
countOfInvestors++;
privateSetInfo(msg.sender, deposit, withdrawals);
}
} else if (msg.value == 0){
uint256 notReceived = investor.deposit.sub(investor.withdrawals);
uint256 partOfNotReceived = notReceived.mul(100).div(totalNotReceived);
uint256 payAmount = totalSupply.div(100).mul(partOfNotReceived);
require(startOfPayments && investor.insured && notReceived > 0);
investor.insured = false;
msg.sender.transfer(payAmount);
emit Paid(msg.sender, payAmount, notReceived, partOfNotReceived);
}
}
| 1 | 700 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Valid address is required");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| 0 | 12,904 |
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
return false;
}
| 0 | 14,583 |
function setGasLimits(uint256 _gasLimitDepositRelay, uint256 _gasLimitWithdrawConfirm) external onlyOwner {
uintStorage[keccak256("gasLimitDepositRelay")] = _gasLimitDepositRelay;
uintStorage[keccak256("gasLimitWithdrawConfirm")] = _gasLimitWithdrawConfirm;
emit GasConsumptionLimitsUpdated(gasLimitDepositRelay(), gasLimitWithdrawConfirm());
}
| 0 | 18,246 |
function Wallet(address _owner) public {
owner_ = _owner;
exchange_ = msg.sender;
logic_ = connector_.latestLogic_();
birthBlock_ = block.number;
}
| 1 | 7,176 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
if (!transfersEnabled) revert();
if (jail[msg.sender] >= block.timestamp || jail[_to] >= block.timestamp || jail[_from] >= block.timestamp) revert();
if (allowance(_from, msg.sender) < _value) return false;
m_allowance[_from][msg.sender] -= _value;
if (!(doTransfer(_from, _to, _value))) {
m_allowance[_from][msg.sender] += _value;
return false;
}
else {
return true;
}
}
| 0 | 12,066 |
function createNewEscrow(uint256[] memory assedIds, uint256 escrowPrice, bool doesAcceptOffers, bool isPublic, address buyer) public whenNotPaused{
uint256 tempParcelCount = assedIds.length;
for(uint i = 0; i < tempParcelCount; i++)
{
address assetOwner = nonFungibleRegistry.ownerOf(assedIds[i]);
require(msg.sender == assetOwner, "You are not the owner of this parcel.");
require(nonFungibleRegistry.exists(assedIds[i]), "This parcel does not exist.");
require(nonFungibleRegistry.isAuthorized(address(this), assedIds[i]), "You have not authorized DCL Escrow to manage your LAND tokens.");
allOwnerParcelsOnEscrow[assetOwner].push(assedIds[i]);
}
require(escrowPrice > 0, "Please pass a price greater than zero.");
bytes32 escrowId = keccak256(abi.encodePacked(
block.timestamp,
msg.sender,
assedIds[0],
escrowPrice
));
assetIdByEscrowId[escrowId] = assedIds;
Escrow memory memEscrow = Escrow({
id: escrowId,
seller: msg.sender,
buyer: buyer,
price: escrowPrice,
offer:0,
publicE:isPublic,
acceptsOffers: doesAcceptOffers,
escrowByOwnerIdPos: 0,
parcelCount: tempParcelCount,
highestBidder: address(0),
lastOfferPrice: 0
});
escrowByEscrowId[escrowId] = memEscrow;
escrowByOwnerId[msg.sender].push(memEscrow);
allEscrowIds.push(escrowId);
emit EscrowCreated(
escrowId,
msg.sender,
buyer,
escrowPrice,
doesAcceptOffers,
isPublic,
tempParcelCount
);
}
| 1 | 3,995 |
function bidTransfer(uint256 _tokenId, address _buyer, uint256 _bidAmount) public canTransact {
Sale memory sale = tokenIdToSale[_tokenId];
address seller = sale.seller;
require (now > sale.startedAt.add(BID_DELAY_TIME));
uint256[9] memory tokenIdsStore = tokenIdToSale[_tokenId].tokenIds;
require(_isOnSale(sale));
uint256 price = _currentPrice(sale);
require(_bidAmount >= price);
if(tokenIdsStore[1] > 0) {
for(uint ii = 0; ii < 9; ii++) {
_removeSale(tokenIdsStore[ii]);
}
} else {
_removeSale(_tokenId);
}
uint256 marketsCut = 0;
uint256 sellerProceeds = 0;
if (price > 0) {
marketsCut = _computeCut(price);
sellerProceeds = price.sub(marketsCut);
}
require (LSEscrowContract.escrowTransfer(seller, _buyer, sellerProceeds, marketsCut));
if(tokenIdsStore[1] > 0) {
emit TeamSaleWinner(tokenIdsStore, price, _buyer);
} else {
emit SaleWinner(_tokenId, price, _buyer);
}
if(sale.tokenIds[1] > 0) {
for (uint256 i = 0; i < 9; i++) {
_transfer(address(this), _buyer, sale.tokenIds[i]);
}
price = price.div(9);
} else {
_transfer(address(this), _buyer, _tokenId);
}
if (seller == address(this)) {
if(sale.tokenIds[1] > 0) {
uint256 _teamId = nonFungibleContract.getTeamId(_tokenId);
lastTeamSalePrices[_teamId][seedTeamSaleCount[_teamId] % 3] = price;
seedTeamSaleCount[_teamId]++;
} else {
lastSingleSalePrices[seedSingleSaleCount % 10] = price;
seedSingleSaleCount++;
}
}
}
| 1 | 1,314 |
function userTokenBalance(address _userAddress) constant returns(uint256 balance) {
return token.balanceOf(_userAddress);
}
| 0 | 14,802 |
function updateInvestorFunds(uint tokenAmount, uint weiAmount, address receiver, uint128 customerId) private {
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 764 |
function () payable {
uint amount = msg.value;
if (crowdsaleClosed || amount < 0.1 ether) throw;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokensForSending = amount / price;
tokenReward.transfer(msg.sender, tokensForSending);
tokensCounter += tokensForSending;
FundTransfer(msg.sender, amount, true);
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
}
}
| 1 | 7,949 |
function addGuardian(BaseWallet _wallet, address _guardian) external onlyOwner(_wallet) onlyWhenUnlocked(_wallet) {
require(!isOwner(_wallet, _guardian), "GM: target guardian cannot be owner");
require(!isGuardian(_wallet, _guardian), "GM: target is already a guardian");
require(_guardian.call.gas(5000)(abi.encodeWithSignature("owner()")), "GM: guardian must be EOA or implement owner()");
if(guardianStorage.guardianCount(_wallet) == 0) {
guardianStorage.addGuardian(_wallet, _guardian);
emit GuardianAdded(_wallet, _guardian);
} else {
bytes32 id = keccak256(abi.encodePacked(address(_wallet), _guardian, "addition"));
GuardianManagerConfig storage config = configs[_wallet];
require(
config.pending[id] == 0 || now > config.pending[id] + securityWindow,
"GM: addition of target as guardian is already pending");
config.pending[id] = now + securityPeriod;
emit GuardianAdditionRequested(_wallet, _guardian, now + securityPeriod);
}
}
| 1 | 5,537 |
function returnDeposit() isIssetUser private {
require(((maxReturn.sub(ruturnedOfThisDay) > 0) || (dayOfLastReturn != now.div(1 days))), 'Day limit of return is ended');
require(usersInvestment[msg.sender].sub(usersInvestment[msg.sender].mul(projectPercent).div(100)) > dividends[msg.sender].add(payoutAmount()), 'You have already repaid your 91% of deposit. Use 0!');
collectPercent();
uint withdrawalAmount = usersInvestment[msg.sender].sub(dividends[msg.sender]).sub(usersInvestment[msg.sender].mul(projectPercent).div(100));
if(dayOfLastReturn!=now.div(1 days)) { ruturnedOfThisDay = 0; dayOfLastReturn = now.div(1 days); }
if(withdrawalAmount > maxReturn.sub(ruturnedOfThisDay)){
withdrawalAmount = maxReturn.sub(ruturnedOfThisDay);
usersInvestment[msg.sender] = usersInvestment[msg.sender].sub(withdrawalAmount.add(dividends[msg.sender]).mul(100).div(100-projectPercent));
usersTime[msg.sender] = now;
dividends[msg.sender] = 0;
}
else
{
usersInvestment[msg.sender] = 0;
usersTime[msg.sender] = 0;
dividends[msg.sender] = 0;
}
ruturnedOfThisDay += withdrawalAmount;
msg.sender.transfer(withdrawalAmount);
}
| 0 | 15,734 |
function TssCrowdsale(
uint256 _rate,
address _wallet,
uint256 _phase_1_start,
uint256 _phase_2_start,
uint256 _phase_3_start,
uint256 _postsale_start,
address _founder_wallet,
address _bounty_wallet,
address _future_wallet,
address _presale_wallet)
public
Crowdsale(_phase_1_start, _postsale_start, _rate, _wallet)
{
CROWDSALE_PHASE_1_START = _phase_1_start;
CROWDSALE_PHASE_2_START = _phase_2_start;
CROWDSALE_PHASE_3_START = _phase_3_start;
POSTSALE_START = _postsale_start;
FOUNDER_WALLET = _founder_wallet;
BOUNTY_WALLET = _bounty_wallet;
FUTURE_WALLET = _future_wallet;
PRESALE_WALLET = _presale_wallet;
CROWDSALE_WALLET = address(this);
assertValidParameters();
currentStage = LifecycleStage.MINTING;
mintTokens();
token.finishMinting();
currentStage = LifecycleStage.PRESALE;
}
| 1 | 8,913 |
function changeDepositBatchFee(uint128) public {
callExternal(depositor);
}
| 0 | 13,227 |
function grantToSetUnpausedWallet(address _to, bool permission) public {
require(owner == msg.sender || msg.sender == Crowdsale(owner).wallets(uint8(Crowdsale.Roles.manager)));
grantedToSetUnpausedWallet[_to] = permission;
}
| 1 | 38 |
function play(uint256 number) payable public {
require(msg.value >= betPrice && number < 16);
Game game;
game.player = msg.sender;
game.number = number;
gamesPlayed.push(game);
if (number == secretNumber) {
if(msg.value*15>this.balance){
msg.sender.transfer(this.balance);
}
else{
msg.sender.transfer(msg.value*15);
}
}
generateNewRandom();
lastPlayed = now;
}
| 0 | 18,653 |
function increasePercent() private {
CBCToken CBCTokenContract = CBCToken(CBCTokenAddress);
MainSale MainSaleContract = MainSale(MainSaleAddress);
Investor storage investor = investors[msg.sender];
if (CBCTokenContract.balanceOf(msg.sender) >= 10){
MainSaleContract.authorizedBurnTokens(msg.sender, 10);
investor.increasedPercent = true;
}
}
| 1 | 1,455 |
function exchange(address _partner, uint _amount) internal {
require(exchangePartners[_partner]);
requestTokensFromOtherContract(_partner, this, msg.sender, _amount);
balances[msg.sender] = sub(balanceOf(msg.sender), _amount);
circulatingSupply = sub(circulatingSupply, _amount);
totalSupply = add(totalSupply, _amount);
Transfer(msg.sender, this, _amount);
}
| 1 | 7,443 |
function startOffering(
uint256 _tokenOffering,
uint256 _bonusRateOneEth,
uint256 _startTime,
uint256 _endTime,
bool _isBurnInClose
) public onlyOwner returns (bool) {
require(_tokenOffering <= balances[owner]);
require(_startTime <= _endTime);
require(_startTime >= block.timestamp);
require(!isOfferingStarted);
isOfferingStarted = true;
startTime = _startTime;
endTime = _endTime;
isBurnInClose = _isBurnInClose;
currentTokenOfferingRaised = 0;
currentTotalTokenOffering = _tokenOffering;
offeringEnabled = true;
setBonusRate(_bonusRateOneEth);
emit OfferingOpens(startTime, endTime, currentTotalTokenOffering, bonusRateOneEth);
return true;
}
| 0 | 12,618 |
function () payable public {
require(reward != address(0));
require(whitelist != address(0));
require(msg.value >= (2 ether / 10));
require(icoHasStarted);
require(!icoHasClosed);
require(valueInUSD != 0);
require(whitelist.isWhitelisted(msg.sender));
if(contributed[msg.sender] == 0) {
participantIndex[nextParticipantIndex] = msg.sender;
nextParticipantIndex += 1;
}
uint256 amountOfWei = msg.value;
contributed[msg.sender] = contributed[msg.sender].add(amountOfWei);
currentAmountRaised = currentAmountRaised.add(amountOfWei);
uint256 tokens = tokensToMint(amountOfWei);
reward.mintTokens(msg.sender, tokens);
currentAmountOfTokens = currentAmountOfTokens.add(tokens);
emit Received(msg.sender, msg.value);
emit TokensGiven(msg.sender, tokens);
if(address(this).balance >= 50 ether) {
if(!address(recipient).send(address(this).balance)) {
emit ErrorReturningEth(recipient, address(this).balance);
}
}
}
| 1 | 7,241 |
function activate (
address _asset,
uint256 _units,
uint256 _buyPrice,
uint256 _sellPrice,
bool _buysTokens,
bool _sellsTokens
) onlyOwner
{
require(ERC20(exchange).approve(baseowner,exchFee));
require(ERC20(exchange).transfer(baseowner,exchFee));
asset = _asset;
units = _units;
buyPrice = _buyPrice;
sellPrice = _sellPrice;
buysTokens = _buysTokens;
sellsTokens = _sellsTokens;
ActivatedEvent(buysTokens, sellsTokens);
}
| 1 | 2,894 |
function verifyTransferBlock(uint32, uint256[8] memory) public {
callExternal(transactor);
}
| 0 | 17,984 |
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
| 0 | 15,886 |
function doWithdraw() internal {
if (!multisig.send(this.balance)) throw;
}
| 0 | 10,317 |
function claimTokens(address _token) onlyController public {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
ERC20Token token = ERC20Token(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
| 1 | 1,053 |
function () external payable {
require(customerWallet == address(0x0));
customerWallet = msg.sender;
started = now;
orderLastDate = started + PERIOD;
safeLastDate = orderLastDate + SAFE_PERIOD;
}
| 0 | 16,084 |
function initializeCurve(
bytes32 endpoint,
bytes32 symbol,
int256[] curve
) public returns(address) {
require(curves[endpoint] == 0, "Curve endpoint already exists or used in the past. Please choose a new endpoint");
RegistryInterface registry = RegistryInterface(coord.getContract("REGISTRY"));
registry.initiateProviderCurve(endpoint, curve, address(this));
curves[endpoint] = newToken(bytes32ToString(endpoint), bytes32ToString(symbol));
curves_list.push(endpoint);
registry.setProviderParameter(endpoint, toBytes(curves[endpoint]));
DotTokenCreated(curves[endpoint]);
return curves[endpoint];
}
| 1 | 8,079 |
function ticketString(uint256 _nonce) public view returns (string memory) {
bytes32 ticketAddressBytes = addressBytesFrom(targetAddress, _nonce);
return ticketStringFromAddressBytes(ticketAddressBytes);
}
| 0 | 13,442 |
function tokenPause() onlyOwner public {
token.pause();
}
| 1 | 5,714 |
function createSaleAuction(
uint256 _playerTokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
public
whenNotPaused
{
require(_owns(msg.sender, _playerTokenId));
_approve(_playerTokenId, saleClockAuctionContract);
saleClockAuctionContract.createAuction(
_playerTokenId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 5,440 |
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
require(_investednum > 0 && investedAmount[_investor] >= _investednum);
require(!investorVault[_investor][_investednum].withdrawn);
require(token.balanceOf(address(this)) >= investorVault[_investor][_investednum].value);
adminWithdraw[_investor][_investednum][_target][msg.sender] = true;
for (uint256 i = 0; i < admins.length; i++) {
if (!adminWithdraw[_investor][_investednum][_target][admins[i]]) {
return;
}
}
require(token.transfer(_target, investorVault[_investor][_investednum].value));
investorVault[_investor][_investednum].withdrawn = true;
emit FPWithdrawnByAdmins(_target, investorVault[_investor][_investednum].value, _investor,
_investednum, investorVault[_investor][_investednum].fpnum);
}
| 1 | 5,268 |
function withdraw() external {
require(!allocations[msg.sender].hasWithdrawn);
require(block.timestamp > SimpleTGEContract.publicTGEEndBlockTimeStamp().add(SimpleTGEContract.TRSOffset()));
require(SimplePreTGEContract.allocationsLocked());
bool _preTGEHasVested;
uint256 _preTGEWeiContributed;
bool _publicTGEHasVested;
uint256 _publicTGEWeiContributed;
(_publicTGEHasVested, _publicTGEWeiContributed) = SimpleTGEContract.contributions(msg.sender);
(_preTGEHasVested, _preTGEWeiContributed) = SimplePreTGEContract.contributions(msg.sender);
uint256 _totalWeiContribution = _preTGEWeiContributed.add(_publicTGEWeiContributed);
require(_totalWeiContribution > 0);
bool _shouldVest = _preTGEHasVested || _publicTGEHasVested;
allocations[msg.sender].hasWithdrawn = true;
allocations[msg.sender].shouldVest = _shouldVest;
allocations[msg.sender].weiContributed = _totalWeiContribution;
uint256 _lstAllocated;
if (!_shouldVest) {
_lstAllocated = LSTRatePerWEI.mul(_totalWeiContribution);
allocations[msg.sender].LSTAllocated = _lstAllocated;
require(token.mint(msg.sender, _lstAllocated));
LogLSTsWithdrawn(msg.sender, _lstAllocated);
}
else {
_lstAllocated = LSTRatePerWEI.mul(_totalWeiContribution).mul(vestingBonusMultiplier).div(vestingBonusMultiplierPrecision);
allocations[msg.sender].LSTAllocated = _lstAllocated;
uint256 _withdrawNow = _lstAllocated.div(10);
uint256 _vestedPortion = _lstAllocated.sub(_withdrawNow);
vesting[msg.sender] = new TokenVesting(msg.sender, vestingStartTime, 0, vestingDuration, false);
require(token.mint(msg.sender, _withdrawNow));
LogLSTsWithdrawn(msg.sender, _withdrawNow);
require(token.mint(address(vesting[msg.sender]), _vestedPortion));
LogTimeVestingLSTsWithdrawn(address(vesting[msg.sender]), _vestedPortion, vestingStartTime, 0, vestingDuration);
}
}
| 1 | 2,807 |
function setStartTimeTLP1(uint256 _at) onlyOwner {
require(block.timestamp < startTimeTLP1);
require(block.timestamp < _at);
startTimeTLP1 = _at;
endTimeTLP1 = startTimeTLP1.add(daysTLP1);
SetStartTimeTLP1(_at);
}
| 0 | 17,583 |
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;
}
}
| 0 | 12,777 |
constructor() public {
_zer0netDb = Zer0netDbInterface(0xE865Fe1A1A3b342bF0E2fcB11fF4E3BCe58263af);
bytes32 hash = keccak256(abi.encodePacked('aname.', _namespace));
_predecessor = _zer0netDb.getAddress(hash);
if (_predecessor != 0x0) {
uint lastRevision = Nametag(_predecessor).getRevision();
_revision = lastRevision + 1;
}
}
| 1 | 304 |
function sqrt(uint256 x) public pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
| 0 | 19,238 |
function getStageStartTime(bytes32 stageId) public view returns(uint256) {
return startTime[stageId];
}
| 0 | 17,207 |
function stopSecondSale() public onlyOwner{
presaleOpen = false;
firstsaleOpen = false;
secondsaleOpen = false;
if(teamAdvTokens >= 0 && bountyTokens >=0){
TokenAllocate(teamsWallet,teamAdvTokens);
teamAdvTokens = 0;
TokenAllocate(bountyWallet,bountyTokens);
bountyTokens = 0;
}
}
| 1 | 5,468 |
function finalize() external ownerOnly {
if (isFinalized) {
revert();
}
pair.disableTransfers(false);
isFinalized = true;
}
| 1 | 4,309 |
function finalizeTDE()
onlyCofounders
TDEHasEnded
{
require(dnnToken.tokensLocked() == true && dnnToken.PRETDESupplyRemaining() == 0);
dnnToken.unlockTokens();
tokensDistributed += dnnToken.TDESupplyRemaining();
dnnToken.sendUnsoldTDETokensToPlatform();
}
| 0 | 10,124 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
contractBalance -= 57245901639344;
totalBets += 1;
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1 | 5,942 |
function escape(address escapeAddress) onlyOwner {
address tokenAddress = ContractProvider(CONTRACT_PROVIDER_ADDRESS).contracts("digitalGBP");
Token(tokenAddress).transfer(escapeAddress, total);
total = 0;
}
| 1 | 9,529 |
function refund() external {
if (isFinalized) revert();
if (block.number <= fundingEndBlock) revert();
if (totalSupply >= minCap) revert();
if (msg.sender == owner) revert();
uint256 mpyVal = balances[msg.sender];
if (mpyVal == 0) revert();
balances[msg.sender] = 0;
totalSupply = safeSubtract(totalSupply, mpyVal);
uint256 ethVal = mpyVal / tokenExchangeRate;
MPYRefund(msg.sender, ethVal);
if (!msg.sender.send(ethVal)) revert();
}
| 0 | 12,463 |
function claimLoot(uint encounterId, address player) public whenNotPaused {
address winnerAddress;
uint lootTokenId;
uint consolationPrizeTokenId;
(winnerAddress, lootTokenId, consolationPrizeTokenId, , ,,) = getEncounterResults(encounterId, player);
require(winnerAddress == player, "player is not the winner");
ParticipantData storage participantData = encountersById[encounterId].participantData[player];
require(!participantData.lootClaimed, "loot already claimed");
participantData.lootClaimed = true;
tokenContract.mint(player, lootTokenId);
require(consolationPrizeTokenId != 0, "consolation prize invalid");
if (!participantData.consolationPrizeClaimed) {
participantData.consolationPrizeClaimed = true;
tokenContract.mint(player, consolationPrizeTokenId);
msg.sender.transfer(gasRefundForClaimLootWithConsolationPrize);
} else {
msg.sender.transfer(gasRefundForClaimLoot);
}
emit LootClaimed(player, encounterId);
}
| 1 | 511 |
function harvest()
external
onlyHelper
returns (uint)
{
require(teamPoolForFrozenTokens != 0x0);
uint currentTimeDiff = getBlockTimestamp().sub(startTime);
uint secondsPerDay = 24 * 3600;
uint daysFromStart = currentTimeDiff.div(secondsPerDay);
uint currentDay = daysFromStart.add(1);
if (getBlockTimestamp() >= endTime) {
currentTimeDiff = endTime.sub(startTime).add(1);
currentDay = 5 * 365;
}
uint maxCurrentHarvest = currentDay.mul(unfrozePerDay);
uint wasNotHarvested = maxCurrentHarvest.sub(alreadyHarvestedTokens);
require(wasNotHarvested > 0);
require(token.issueTokens(teamPoolForFrozenTokens, wasNotHarvested));
alreadyHarvestedTokens = alreadyHarvestedTokens.add(wasNotHarvested);
return wasNotHarvested;
}
| 1 | 7,889 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.