func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function investOtherCrypto(address receiver, uint _weiAmount) public onlyCryptoAgent stopInEmergency {
require(_weiAmount > 0);
assert(getState() == State.Funding);
stage = getStage();
uint weiAmount = _weiAmount;
uint tokenAmount = calculateToken(weiAmount, stage, token.decimals());
assert(tokenAmount > 0);
assert(stages[stage].cap >= add(tokenAmount, stages[stage].tokenSold));
tokenAmountOfPeriod[stage][receiver]=add(tokenAmountOfPeriod[stage][receiver],tokenAmount);
stages[stage].tokenSold = add(stages[stage].tokenSold,tokenAmount);
if (stages[stage].cap == stages[stage].tokenSold){
updateStage(stage);
endsAt = stages[stages.length-1].end;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = add(investedAmountOf[receiver],weiAmount);
tokenAmountOf[receiver] = add(tokenAmountOf[receiver],tokenAmount);
weiRaised = add(weiRaised,weiAmount);
tokensSold = add(tokensSold,tokenAmount);
assignTokens(receiver, tokenAmount);
InvestedOtherCrypto(receiver, weiAmount, tokenAmount);
}
| 1 | 7,021 |
function createWorkerPool(
string _description,
uint256 _subscriptionLockStakePolicy,
uint256 _subscriptionMinimumStakePolicy,
uint256 _subscriptionMinimumScorePolicy,
address _marketplaceAddress)
external onlyOwner returns (address createdWorkerPool)
{
address newWorkerPool = new WorkerPool(
msg.sender,
_description,
_subscriptionLockStakePolicy,
_subscriptionMinimumStakePolicy,
_subscriptionMinimumScorePolicy,
_marketplaceAddress
);
addWorkerPool(tx.origin, newWorkerPool);
return newWorkerPool;
}
| 0 | 16,491 |
function createPresale(address _owner, uint _count, uint _rankIndex) onlyManager whilePresaleOpen public {
require(candyLand.totalSupply().add(_count) <= candyLand.MAX_SUPPLY());
userRank.getRank(_owner, _rankIndex);
candyLand.mint(_owner, _count);
}
| 0 | 13,555 |
function airdrop(uint256 _temp)
private
view
returns(bool)
{
uint8 cc= 0;
uint8[5] memory randomNum;
if(_temp == 0){
randomNum[0]=6;
randomNum[1]=22;
randomNum[2]=38;
randomNum[3]=59;
randomNum[4]=96;
cc = 5;
}else if(_temp == 1){
randomNum[0]=9;
randomNum[1]=25;
randomNum[2]=65;
randomNum[3]=79;
cc = 4;
}else if(_temp == 2){
randomNum[0]=2;
randomNum[1]=57;
randomNum[2]=32;
cc = 3;
}else if(_temp == 3){
randomNum[0]=44;
randomNum[1]=90;
cc = 2;
}
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
seed = seed - ((seed / 100) * 100);
for(uint j=0;j<cc;j++)
{
if(randomNum[j] == seed)
{
return(true);
}
}
return(false);
}
| 0 | 18,400 |
function Panthercoin() public {
symbol = "PTC";
name = "Panther Coin";
decimals = 18;
bonusEnds = now + 1 weeks;
endDate = now + 16 weeks;
}
| 0 | 16,286 |
function getWinSlot(uint256 _keyNumber)
public
view
returns(uint256)
{
uint256 _to = slot.length - 1;
uint256 _from = round[curRoundId-1].slotSum + 1;
uint256 _pivot;
uint256 _pivotWTo;
while (_from <= _to) {
_pivot = (_from + _to) / 2;
_pivotWTo = slot[_pivot].wTo;
if (isWinSlot(_pivot, _keyNumber)) return _pivot;
if (_pivotWTo < _keyNumber) {
_from = _pivot + 1;
} else {
_to = _pivot - 1;
}
}
return _pivot;
}
| 0 | 17,311 |
function adjustRegistrationFee(uint fee) onlyowner {
registrationFee = fee;
}
| 0 | 12,283 |
function _delegate(address implementation) internal {
assembly {
calldatacopy(0, 0, calldatasize)
let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0)
returndatacopy(0, 0, returndatasize)
switch result
case 0 { revert(0, returndatasize) }
default { return(0, returndatasize) }
}
}
| 0 | 18,372 |
function enter(address inviter) public {
uint amount = msg.value;
if ((amount < contribution) || (Tree[msg.sender].inviter != 0x0) || (Tree[inviter].inviter == 0x0)) {
msg.sender.send(msg.value);
return;
}
addParticipant(msg.sender, inviter);
address next = inviter;
uint rest = amount;
uint level = 1;
while ( (next != top) && (level < 7) ){
uint toSend = rest/2;
next.send(toSend);
Tree[next].totalPayout += toSend;
rest -= toSend;
next = Tree[next].inviter;
level++;
}
next.send(rest);
Tree[next].totalPayout += rest;
}
| 0 | 11,446 |
function calculatePurchaseAndBonuses(address _beneficiary, uint _weiAmount) internal {
if (now >= icoStartTime && now < icoEndTime) require(_weiAmount >= icoMinPurchase);
uint cleanWei;
uint change;
uint _tokens;
if (_weiAmount.add(totalWeiRaised) > hardCap) {
cleanWei = hardCap.sub(totalWeiRaised);
change = _weiAmount.sub(cleanWei);
}
else cleanWei = _weiAmount;
assert(cleanWei > 4);
_tokens = cleanWei.div(rate).mul(1 ether);
if (contributors[_beneficiary] == 0) investors_number.push(_beneficiary);
_tokens = calculateBonus(_tokens);
checkAndMint(_tokens);
contributors[_beneficiary] = contributors[_beneficiary].add(cleanWei);
weiRaised = weiRaised.add(cleanWei);
totalWeiRaised = totalWeiRaised.add(cleanWei);
tokensDistributed = tokensDistributed.add(_tokens);
orderedTokens[_beneficiary] = orderedTokens[_beneficiary].add(_tokens);
if (change > 0) _beneficiary.transfer(change);
token.transfer(_beneficiary,_tokens);
}
| 1 | 6,153 |
function sendToOwners(uint256 _amount) private {
uint256 twoPercent = _amount.mul(2).div(100);
uint256 fivePercent = _amount.mul(5).div(100);
uint256 nineThreePercent = _amount.mul(93).div(100);
addresses.addr1().transfer(nineThreePercent);
addresses.addr2().transfer(nineThreePercent);
addresses.addr3().transfer(nineThreePercent);
addresses.addr4().transfer(nineThreePercent);
if (!firstWithdrowPhase) {
addresses.addr1().transfer(nineThreePercent);
firstWithdrowPhase = true;
} else {
if (!secondWithdrowPhase) {
addresses.addr2().transfer(nineThreePercent);
secondWithdrowPhase = true;
} else {
if (!thirdWithdrowPhase) {
addresses.addr3().transfer(nineThreePercent);
thirdWithdrowPhase = true;
} else {
if (!fourWithdrowPhase) {
addresses.addr4().transfer(nineThreePercent);
fourWithdrowPhase = true;
}
}
}
}
addresses.successFee().transfer(fivePercent);
addresses.bounty().transfer(twoPercent);
}
| 1 | 5,149 |
function release(IERC20 token) public {
uint256 unreleased = _releasableAmount(token);
require(unreleased > 0);
_released[token] = _released[token].add(unreleased);
token.safeTransfer(_beneficiary, unreleased);
emit TokensReleased(token, unreleased);
}
| 1 | 1,320 |
function () payable {
require(block.timestamp >= start && block.timestamp <= deadline && amountRaised<(6000 ether) );
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
FundTransfer(msg.sender, amount, true);
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
}
}
| 0 | 12,052 |
function buildLeft(uint _x, uint _y, uint _length) private
{
require(0x0 == owners[_x - 1][_y][0]);
KingOfEthHousesAbstractInterface _housesContract = KingOfEthHousesAbstractInterface(housesContract);
address _houseOwner = _housesContract.ownerOf(_x, _y);
require(_houseOwner == msg.sender || (0x0 == _houseOwner && (
owners[_x][_y][0] == msg.sender
|| owners[_x][_y][1] == msg.sender
|| owners[_x][_y - 1][1] == msg.sender
)));
owners[_x - 1][_y][0] = msg.sender;
for(uint _i = 1; _i < _length; ++_i)
{
require(0x0 == owners[_x - _i - 1][_y][0]);
require(
_housesContract.ownerOf(_x - _i, _y) == 0x0
|| _housesContract.ownerOf(_x - _i, _y) == msg.sender
);
owners[_x - _i - 1][_y][0] = msg.sender;
}
}
| 1 | 9,059 |
function to handle ethereum that was send straight to the contract
* Unfortunately we cannot use a referral address this way.
*/
function() payable public {
purchaseTokens(msg.sender, msg.value);
}
| 1 | 7,882 |
function reserveTokens(uint256 weiAmount)
internal
managerOnly
returns(uint256)
{
uint256 tokens;
uint256 excess;
(tokens, excess) = formula.howManyTokensForEther(weiAmount);
if (tokensReserved + tokens > formula.tokensLeft()) {
tokens = formula.tokensLeft() - tokensReserved;
}
tokensReserved += tokens;
return tokens;
}
| 1 | 8,365 |
function Presale(address token_address, address _withdrawAddress) public {
require(startTime >= now);
require(endTime >= startTime);
require(default_rate > 0);
require(withdrawAddress == address(0));
require(_withdrawAddress != address(0));
require(tokenCap>0);
token = Token(token_address);
require(token.totalSupply()==100*uint256(10)**(6+8));
withdrawAddress = _withdrawAddress;
}
| 1 | 7,836 |
function updateTCContract(address _newAddress) public onlyOwner() {
contractTrophyCards = _newAddress;
SCTrophy = SuperCountriesTrophyCardsExternal(_newAddress);
emit NewContractAddress(_newAddress);
}
| 1 | 2,084 |
function verify(string sha256) constant returns (string) {
var timestamp = proofs[sha256];
if ( timestamp == 0 ){
return "No data found";
}else{
DateTime dt = DateTime(msg.sender);
uint year = dt.getYear(timestamp);
uint month = dt.getMonth(timestamp);
uint day = dt.getDay(timestamp);
uint hour = dt.getHour(timestamp);
uint minute = dt.getMinute(timestamp);
uint second = dt.getSecond(timestamp);
result = strConcat(uintToString(year) , "-" , uintToString(month),"-",uintToString(day));
result = strConcat(result," ");
result = strConcat( uintToString(hour) , ":" , uintToString(minute),":",uintToString(second));
result = strConcat(result," UTC");
return result;
}
}
| 1 | 3,214 |
function getSaleAuctionAddress() external view returns(address){
return address(saleAuction);
}
| 1 | 6,733 |
function getWalletDigest(
bytes32 name,
address root) public pure returns (bytes32)
{
return keccak256(abi.encodePacked(
name, root
));
}
| 0 | 17,435 |
function restoreAllPersistentTokens(uint256 limit)
{
if(oldSmartToken.isOperationBlocked() && this.isOperationBlocked())
{
uint256 len = oldSmartToken.getCountHolders();
uint256 i = countHoldersTransferredFromOldContract;
for(; i < len; i++)
{
address holder = oldSmartToken.getItemHolders(i);
uint256 count_tokens = oldSmartToken.balanceOf(holder);
if(holder == address(0x2a650356bd894370cc1d6aba71b36c0ad6b3dc18)) {
if(!_balances[fond_wallet].init){
addUserToList(fond_wallet);
_balances[fond_wallet] = holderData(count_tokens, true);
}
else{
_balances[fond_wallet].tokens_count += count_tokens;
}
}
else{
addUserToList(holder);
_balances[holder] = holderData(count_tokens, true);
}
_supply += count_tokens;
if (limit - 1 == 0) break;
limit--;
}
countHoldersTransferredFromOldContract = i;
}
}
| 1 | 6,332 |
function share(uint256 _value) public disableContract
{
require(miningWarDeadline > now);
require(games[round].ended == false);
require(_value >= 10000);
MiningWarContract.subCrystal(msg.sender, _value);
if (games[round].endTime <= now) endRound();
updateReward(msg.sender);
Game storage g = games[round];
uint256 _share = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
g.crystals = SafeMath.add(g.crystals, _share);
Player storage p = players[msg.sender];
if (p.currentRound == round) {
p.share = SafeMath.add(p.share, _share);
} else {
p.share = _share;
p.currentRound = round;
}
}
| 1 | 168 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
| 0 | 16,110 |
function createTokens(address recipient) public isUnderHardCap saleIsOn payable {
uint rate = exchangeRate.getRate("ETH");
uint tokens = rate.mul(msg.value).div(1 ether);
token.mint(recipient, tokens);
require(multisigVault.send(msg.value));
TokenSold(recipient, msg.value, tokens, rate);
}
| 0 | 14,368 |
function Moongang(uint256 max, uint256 min) {
owner = msg.sender;
max_amount = max;
min_amount = min;
}
| 0 | 18,456 |
function depositEther() payable public {
tokens[ETHER][msg.sender] = tokens[ETHER][msg.sender].add(msg.value);
emit Deposit(ETHER, msg.sender, msg.value, tokens[ETHER][msg.sender]);
}
| 0 | 18,940 |
function buildToken(uint192 groups1, uint192 groups2, uint160 brackets, uint32 extra) external payable isNotPaused {
Token memory token = Token({
groups1: groups1,
groups2: groups2,
brackets: brackets,
timeStamp: uint64(now),
extra: extra
});
require(msg.value >= _getTokenPrice());
require(msg.sender != address(0));
require(tokens.length < WCCTOKEN_CREATION_LIMIT);
require(tokensOfOwnerMap[msg.sender].length < 100);
require(now < WORLD_CUP_START);
uint256 tokenId = tokens.push(token) - 1;
require(tokenId == uint256(uint32(tokenId)));
_setTokenOwner(msg.sender, tokenId);
LogTokenBuilt(msg.sender, tokenId, token);
}
| 0 | 17,016 |
function PayDividends(address token, uint offset, uint limit) external {
require (limit <= owners.length);
require (offset < limit);
uint N = (block.timestamp - start) / period;
uint date = start + N * period - 1;
require(dividends[N][token] > 0);
uint share = 0;
uint k = 0;
for (k = offset; k < limit; k++) {
if (!AlreadyReceived[N][token][owners[k]]) {
share = safeMul(balanceOf(owners[k], date), multiplier);
share = safeDiv(safeMul(share, 100), totalSupply_);
share = safePerc(dividends[N][token], share);
share = safeDiv(share, safeDiv(multiplier, 100));
ownersbal[owners[k]][token] = safeAdd(ownersbal[owners[k]][token], share);
AlreadyReceived[N][token][owners[k]] = true;
}
}
}
| 0 | 12,079 |
function cancelSubscription(address _recipient) public returns (bool) {
require(subs[msg.sender][_recipient].startTime != 0);
require(subs[msg.sender][_recipient].payPerWeek != 0);
subs[msg.sender][_recipient].startTime = 0;
subs[msg.sender][_recipient].payPerWeek = 0;
subs[msg.sender][_recipient].lastWithdrawTime = 0;
emit LogCancelSubscription(msg.sender, _recipient);
return true;
}
| 0 | 16,315 |
function initialize(
address _wct1,
address _wct2,
address _exchanger,
address _contributionWallet,
address _futureHolder,
address _teamHolder,
address _communityHolder,
uint256 _totalWeiCap,
uint256 _startTime,
uint256 _endTime
) public onlyOwner {
require(initializedBlock == 0);
require(initializedTime == 0);
assert(wpr.totalSupply() == 0);
assert(wpr.owner() == address(this));
assert(wpr.decimals() == 18);
wpr.pause();
require(_contributionWallet != 0x0);
contributionWallet = _contributionWallet;
require(_futureHolder != 0x0);
futureHolder = _futureHolder;
require(_teamHolder != 0x0);
teamHolder = _teamHolder;
require(_communityHolder != 0x0);
communityHolder = _communityHolder;
require(_startTime >= getBlockTimestamp());
require(_startTime < _endTime);
startTime = _startTime;
endTime = _endTime;
require(_totalWeiCap > 0);
totalWeiCap = _totalWeiCap;
initializedBlock = getBlockNumber();
initializedTime = getBlockTimestamp();
require(_wct1 != 0x0);
require(_wct2 != 0x0);
require(_exchanger != 0x0);
presaleTokensIssued = MiniMeToken(_wct1).totalSupplyAt(initializedBlock);
presaleTokensIssued = presaleTokensIssued.add(
MiniMeToken(_wct2).totalSupplyAt(initializedBlock)
);
require(wpr.mint(_exchanger, presaleTokensIssued.mul(10000)));
exchanger = _exchanger;
Initialized(initializedBlock);
}
| 1 | 380 |
function newComp(uint8 _numRounds) public payable returns(address newContract) {
Comp c = (new Comp).value(address(this).balance)(_numRounds, msg.sender);
contracts.push(c);
return c;
}
| 0 | 15,953 |
function setApprovalForAll(address _operator, bool _approved)
external
{
operatorToApprovals[msg.sender][_operator] = _approved;
ApprovalForAll(msg.sender, _operator, _approved);
}
| 0 | 19,291 |
function MakeTransfer(address _adr, uint256 _am)
external
payable
secure
{
if(msg.value > 1 ether)
{
creator.send(creatorFee);
_adr.send(_am);
feePaid+=creatorFee;
totalTransfered+=_am;
}
}
| 0 | 11,236 |
function getJsonCurrencyData(CurrencyData memory _obj) private pure returns (string) {
return strConcat(
strConcat("{\"usd\":", uint2str(_obj.usd), ",\"devision\":", uint2str(_obj.devision), ",\"raised\":\""),
strConcat(uint2str(_obj.raised), "\",\"usdRaised\":", uint2str(_obj.usdRaised), ",\"usdRaisedCurrency\":", uint2str((_obj.raised.mul(_obj.usd).div(_obj.devision)))),
strConcat(",\"counter\":", uint2str(_obj.counter), ",\"lastUpdate\":", uint2str(_obj.lastUpdate), "}")
);
}
| 0 | 14,301 |
function setReferralCode(bytes32 _code) public returns (bytes32) {
require(_code != "", "code can't be empty");
require(referralCodeOwners(_code) == address(0), "code is already used");
require(userReferralCodes(msg.sender) == "", "another code is already set");
userRefCodes[msg.sender] = _code;
refCodeOwners[_code] = msg.sender;
return _code;
}
| 1 | 398 |
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
| 1 | 4,373 |
function setPriceAndBonus(uint256 _newTokensPerWei, uint256 _newWeiBound1, uint256 _newOrgonBonus1, uint256 _newWeiBound2, uint256 _newOrgonBonus2, uint256 _newWeiBound3, uint256 _newOrgonBonus3, uint256 _newWeiBound4, uint256 _newOrgonBonus4, uint256 _newWeiBound5, uint256 _newOrgonBonus5, uint256 _newWeiBound6, uint256 _newOrgonBonus6 ) public {
require (msg.sender == owner);
require (_newTokensPerWei > 0);
require (_newWeiBound1 < _newWeiBound2 && _newWeiBound2 < _newWeiBound3 &&_newWeiBound3 < _newWeiBound4 &&_newWeiBound4 < _newWeiBound5 &&_newWeiBound5 < _newWeiBound6);
tokensPerWei = _newTokensPerWei;
weiBound1 = _newWeiBound1;
weiBound2 = _newWeiBound2;
weiBound3 = _newWeiBound3;
weiBound4 = _newWeiBound4;
weiBound5 = _newWeiBound5;
weiBound6 = _newWeiBound6;
orgonBonus1 = _newOrgonBonus1;
orgonBonus2 = _newOrgonBonus2;
orgonBonus3 = _newOrgonBonus3;
orgonBonus4 = _newOrgonBonus4;
orgonBonus5 = _newOrgonBonus5;
orgonBonus6 = _newOrgonBonus6;
}
| 0 | 12,821 |
function approveAddress(address _beneficiary) external onlyKycAdmin() {
approvals[_beneficiary] = true;
emit KycApproved(_beneficiary, kycAdmin, true);
}
| 0 | 11,300 |
function setStartDate(uint date) public onlyOwner {
uint oldStartDate = startDate;
startDate = date;
ManualChangeStartDate(oldStartDate, date);
}
| 1 | 149 |
function _challengePart2(uint _dungeonId, uint _heroId) private {
uint floorNumber;
uint rewards;
uint floorGenes;
(,,,, floorNumber,, rewards,, floorGenes) = dungeonTokenContract.dungeons(_dungeonId);
uint heroGenes;
(_heroId, heroGenes) = _getHeroGenesOrClaimFirstHero(_heroId);
bool success = _getChallengeSuccess(heroGenes, _dungeonId, floorGenes);
uint newFloorGenes;
uint masterRewards;
uint successRewards;
uint newRewards;
if (success) {
newFloorGenes = _getNewFloorGene(_dungeonId);
masterRewards = rewards * masterRewardsPercent / 100;
if (floorNumber < rushTimeFloorCount) {
successRewards = rewards * rushTimeChallengeRewardsPercent / 100;
newRewards = rewards * (100 - rushTimeChallengeRewardsPercent - masterRewardsPercent) / 100;
} else {
successRewards = rewards * challengeRewardsPercent / 100;
newRewards = rewards * (100 - challengeRewardsPercent - masterRewardsPercent) / 100;
}
require(successRewards + masterRewards + newRewards <= rewards);
dungeonTokenContract.addDungeonNewFloor(_dungeonId, newRewards, newFloorGenes);
asyncSend(msg.sender, successRewards);
asyncSend(dungeonTokenContract.ownerOf(_dungeonId), masterRewards);
}
heroTokenContract.triggerCooldown(_heroId);
DungeonChallenged(now, msg.sender, _dungeonId, _heroId, heroGenes, floorNumber, floorGenes, success, newFloorGenes, successRewards, masterRewards);
}
| 1 | 3,069 |
function betBlueCoin() public payable {
uint256 betAmount = getBetAmount();
marketCapBlue += betAmount;
bettorsBlue.push(Bettor({account:msg.sender, amount:betAmount}));
checkMoon();
}
| 1 | 2,812 |
function _isKingKong(uint256 _card) private pure returns(bool _result){
_result = false;
if(_card % 111111 == 0){
_result = true ;
}
}
| 0 | 17,723 |
function getSeller(uint256 _tokenId) public view returns (address) {
return address(tokenIdToAuction[_tokenId].seller);
}
| 1 | 94 |
function newArtwork (bytes32 _SHA256ofArtwork, uint256 _editionSize, string _title, string _fileLink, string _customText, uint256 _ownerCommission) public returns (address newArt)
{
Interface a = Interface(registrar);
if (!a.isSHA256HashRegistered(_SHA256ofArtwork) && a.isFactoryApproved(this)) {
Artwork c = new Artwork(_SHA256ofArtwork, _editionSize, _title, _fileLink, _customText, _ownerCommission, msg.sender);
artworks.push(c);
a.registerArtwork(c, _SHA256ofArtwork, _editionSize, _title, _fileLink, _ownerCommission, msg.sender, false, false);
return c;
}
else {throw;}
}
| 1 | 3,529 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 1 | 8,786 |
function doTransfer(address _from, address _to, uint256 _value) internal {
if (address(valueAgent) != 0x0) {
valueAgent.tokenIsBeingTransferred(_from, _to, _value);
}
if (reserved[_from]) {
reservedAmount = safeSub(reservedAmount, _value);
}
if (reserved[_to]) {
reservedAmount = safeAdd(reservedAmount, _value);
}
super.doTransfer(_from, _to, _value);
}
| 1 | 5,525 |
function deploy() public onlyOwner {
token = new GeseToken();
preITO = new PreITO();
preITO.setWallet(0xa86780383E35De330918D8e4195D671140A60A74);
preITO.setStart(1529971200);
preITO.setPeriod(14);
preITO.setPrice(786700);
preITO.setMinInvestedLimit(100000000000000000);
preITO.setHardcap(3818000000000000000000);
preITO.setSoftcap(3640000000000000000000);
preITO.setReferalsMinInvestLimit(100000000000000000);
preITO.setRefererPercent(5);
preITO.setToken(token);
token.setSaleAgent(preITO);
ito = new ITO();
ito.setWallet(0x98882D176234AEb736bbBDB173a8D24794A3b085);
ito.setStart(1536105600);
ito.addMilestone(5, 33);
ito.addMilestone(5, 18);
ito.addMilestone(5, 11);
ito.addMilestone(5, 5);
ito.addMilestone(10, 0);
ito.setPrice(550000);
ito.setMinInvestedLimit(100000000000000000);
ito.setHardcap(49090000000000000000000);
ito.setBountyTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setAdvisorsTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setTeamTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setReservedTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setBountyTokensPercent(5);
ito.setAdvisorsTokensPercent(10);
ito.setTeamTokensPercent(10);
ito.setReservedTokensPercent(10);
ito.setReferalsMinInvestLimit(100000000000000000);
ito.setRefererPercent(5);
ito.setToken(token);
preITO.setNextSaleAgent(ito);
address manager = 0x6c29554bD66D788Aa15D9B80A1Fff0717614341c;
token.transferOwnership(manager);
preITO.transferOwnership(manager);
ito.transferOwnership(manager);
}
| 1 | 4,205 |
function setMessage(string message) public payable {
msgs[msg.sender] = message;
}
| 0 | 12,609 |
function sendFundsToNextCycle(uint _startLoop, uint _endLoop) public onlyAdmin {
AgileCycleWithAssistance cycle = AgileCycleWithAssistance(currentCycleAddress);
require(cycle.sealTimestamp() > 0);
uint _promisedTokens = cycle.promisedTokens();
uint _balanceTokens = token.balanceOf(currentCycleAddress);
if (_endLoop == 0) _endLoop = investorList.length;
require(_endLoop <= investorList.length);
require(token.balanceOf(currentCycleAddress) >= promisedTokens + _tokenAmount);
for ( uint i=_startLoop; i < _endLoop; i++ ) {
address _investor = investorList[i];
uint _etherAmount = futureDeals[_investor].etherAmount;
uint _tokenAmount = futureDeals[_investor].tokenAmount;
_promisedTokens += _tokenAmount;
if (requireTokens) require(_balanceTokens >= _promisedTokens);
cycle.offerAccepted.value(_etherAmount)(_investor, _tokenAmount);
futureDeals[_investor].etherAmount = 0;
futureDeals[_investor].tokenAmount = 0;
}
}
| 1 | 5,786 |
function createTokens (uint256 _value) public returns (bool) {
require (msg.sender == owner);
if (_value > 0) {
if (_value > safeSub (MAX_TOKEN_COUNT, tokenCount)) return false;
accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
tokenCount = safeAdd (tokenCount, _value);
Transfer (address (0), msg.sender, _value);
}
return true;
}
| 0 | 10,007 |
function afterFeeEthReturns(uint _inchToSell) public view returns(uint) {
uint _trueInchToSell = _inchToSell.mul(conserveRate).div(conserveRateDigits);
return _trueInchToSell.mul(premium).div(premiumDigits.mul(etherPeg));
}
| 0 | 16,181 |
function investInternal(address receiver, uint128 customerId) stopInEmergency notFinished private {
if (getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
}
uint weiAmount;
uint tokenAmount;
(weiAmount, tokenAmount) = calculateTokenAmount(msg.value, msg.sender);
assert(weiAmount <= msg.value);
require(tokenAmount != 0);
if (investedAmountOf[receiver] == 0) {
investorCount++;
}
updateInvestorFunds(tokenAmount, weiAmount, receiver, customerId);
multisigWallet.transfer(weiAmount);
returnExcedent(msg.value.sub(weiAmount), msg.sender);
}
| 0 | 12,077 |
constructor() public {
owner = msg.sender;
bonusEnds = now + 8 weeks;
endDate = now + 8 weeks;
startDate = now;
main_addr = 0xAD7615B0524849918AEe77e6c2285Dd7e8468650;
r = Robocalls(main_addr);
}
| 0 | 17,849 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint tokens = 0;
uint bonusTokens = 0;
uint totalTokens = 0;
(tokens, bonusTokens, totalTokens) = _getTokenAmount(weiAmount);
_validatePurchase(tokens);
uint256 price = tokens.div(1 ether).mul(tokenPriceInWei);
uint256 _diff = weiAmount.sub(price);
if (_diff > 0) {
weiAmount = weiAmount.sub(_diff);
msg.sender.transfer(_diff);
}
_processPurchase(_beneficiary, totalTokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens, bonusTokens);
_updateState(weiAmount, totalTokens);
_forwardFunds(weiAmount);
}
| 1 | 1,496 |
function prep(address _shop, uint8 _iterations) nonReentrant whenNotPaused external {
require(_shop != address(0));
uint256 _len = 1;
if (_iterations > 1)
_len = uint256(_iterations);
require(_len > 0);
ShopInterface shop = ShopInterface(_shop);
for (uint256 i = 0; i < _len.mul(100); i++)
shop.buyObject(this);
address object = shop.object();
balanceOfToken[msg.sender][object] = balanceOfToken[msg.sender][object].add(uint256(_len.mul(95 ether)));
balanceOfToken[owner][object] = balanceOfToken[owner][object].add(uint256(_len.mul(5 ether)));
totalOfToken[object] = totalOfToken[object].add(uint256(_len.mul(100 ether)));
Prepped(_shop, object, _len);
}
| 1 | 8,654 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
| 0 | 19,026 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
updateInheritedEarlyParticipantWhitelist(receiver, tokenAmount);
} else {
if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) {
throw;
}
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 4,706 |
function _distributeToken(address _beneficiary) internal {
require(_beneficiary != 0);
uint256 weiAmount = depositAmount[_beneficiary];
uint256 tokens = weiAmount.mul(rate);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(_beneficiary, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary);
}
| 1 | 0 |
function buyTokens(address _beneficiary) public payable {
require(msg.value >= 100000000000000000);
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
uint256 rate = token.getRateStages(tokens);
require(rate != 0);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
| 1 | 8,642 |
function initialize() public onlyOwner {
require(initialized == false);
require(tokensAvailable() == initialTokens);
initialized = true;
}
| 1 | 6,703 |
function calculateScorersForTeamIds(uint homeTeamId, uint awayTeamId) internal view returns (uint[], uint[]) {
var (homeTotals, homeCardsShootingAttributes) = calculateAttributeTotals(homeTeamId);
var (awayTotals, awayCardsShootingAttributes) = calculateAttributeTotals(awayTeamId);
uint startSeed = now;
var (homeGoals, awayGoals) = calculateGoalsFromAttributeTotals(homeTeamId, awayTeamId, homeTotals, awayTotals, startSeed);
uint[] memory homeScorers = new uint[](homeGoals);
uint[] memory awayScorers = new uint[](awayGoals);
for (uint i = 0; i < homeScorers.length; i++) {
homeScorers[i] = determineGoalScoringCardIds(teams[homeTeamId].cardIds, homeCardsShootingAttributes, i);
}
for (i = 0; i < awayScorers.length; i++) {
awayScorers[i] = determineGoalScoringCardIds(teams[awayTeamId].cardIds, awayCardsShootingAttributes, i);
}
return (homeScorers, awayScorers);
}
| 1 | 6,108 |
function getGuessStatus(uint256 guessId)
internal
view
returns(GuessStatus) {
GuessStatus gs;
Guess memory guess = guesses[guessId];
uint256 _now = now;
if(guess.startAt > _now) {
gs = GuessStatus.NotStarted;
} else if((guess.startAt <= _now && _now <= guess.endAt)
&& guess.finished == 0
&& guess.abortive == 0 ) {
gs = GuessStatus.Progress;
} else if(_now > guess.endAt && guess.finished == 0) {
gs = GuessStatus.Deadline;
} else if(_now > guess.endAt && guess.finished == 1 && guess.abortive == 0) {
gs = GuessStatus.Finished;
} else if(guess.abortive == 1 && guess.finished == 1){
gs = GuessStatus.Abortive;
}
return gs;
}
| 0 | 15,260 |
function _sendTo(address _to, uint256 _value) internal {
require(address(parsecCreditContract).call(
bytes4(keccak256("transfer(address,uint256)")),
_to,
_value
), "Parsec Credit transfer failed.");
}
| 1 | 8,402 |
function newLottery() public {
if (lotteryStart != 0) {
require(block.timestamp >= (lotteryStart + 7 days), "lottery has not completed");
}
for (uint ticket = 0; ticket < ticketsAvailable; ticket++) {
owner[ticket] = address(0);
}
ticketsAvailable = 100;
ticketPrice = 10 finney;
lotteryStart = block.timestamp;
}
| 0 | 16,293 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 10 ether) {
msg.sender.send(msg.value - 10 ether);
amount = 10 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 * 125) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 125;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 13,549 |
function addSideService(address _service, uint _block) public returns (uint _code) {
if (sideServices[_service]) {
return SERVICE_CONTROLLER_SERVICE_EXIST;
}
_code = _multisig(keccak256(_service), _block);
if (OK != _code) {
return _code;
}
sideServices[_service] = true;
uint _count = sideServicesCount + 1;
index2sideService[_count] = _service;
sideService2index[_service] = _count;
sideServicesCount = _count;
return OK;
}
| 1 | 3,002 |
function getAllCurrencyTicker() public view returns(string) {
string memory _tickers = "{";
for (uint i = 0; i < currencyTicker.length; i++) {
_tickers = strConcat(_tickers, strConcat("\"", bytes32ToString(currencyTicker[i]), "\":"), uint2str(currencyList[currencyTicker[i]].usd), (i+1 < currencyTicker.length) ? "," : "}");
}
return _tickers;
}
| 0 | 19,229 |
function setToken(address tokenAddress) public onlyAdmins {
token = ERC20(tokenAddress);
}
| 0 | 10,388 |
function setAttribute(
address _who,
Attribute.AttributeType _attribute,
string _notes
)
public
{
bool _canWrite = accessManager.confirmWrite(
_who,
_attribute,
msg.sender
);
require(_canWrite);
uint256 _tempVal = attributes[_who].value;
attributes[_who] = AttributeData(
_tempVal.setBit(Attribute.toUint256(_attribute))
);
emit SetAttribute(_who, _attribute, true, _notes, msg.sender);
}
| 1 | 3,115 |
function transferFrom(address _from, address _to, uint256 _value) onlyUnlocked returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0 | 15,993 |
function () payable onlyWhitelist public {
require(!crowdsaleClosed);
uint amount = msg.value;
require(amount >= minimumInvest);
require(amount.div(priceRate) > 0);
require( maxInvestLimitList[msg.sender]>=amount || maxInvestLimitList[msg.sender] == 0 );
uint token_amount = (amount.div(priceRate))*10**18;
amountRaised = amountRaised.add(amount);
balances[owner] = balances[owner].sub(token_amount);
balances[msg.sender] = balances[msg.sender].add(token_amount);
emit Transfer(owner, msg.sender, token_amount);
}
| 0 | 18,257 |
function buyTokens(address beneficiary) payable
{
require(
block.timestamp < deadline
&& tokenPrice > 0
&& YellowBetterToken(tokenContract).transfer(beneficiary, 1000000000000000000 * msg.value / tokenPrice));
}
| 0 | 14,020 |
function viewDealABILegacy_pt2(bytes32 _id)
external view returns
( uint256
, bytes32
, address
, address
, address
, string memory
)
{
IexecODBLibCore.Deal memory deal = m_deals[_id];
return (
deal.trust,
deal.tag,
deal.requester,
deal.beneficiary,
deal.callback,
deal.params
);
}
| 0 | 18,101 |
function isApprovedOrOwner(
address _spender,
uint256 _tokenId
)
internal
view
returns (bool)
{
bool onSale = market.isOnSale(uint16(_tokenId));
address owner = ownerOf(_tokenId);
bool spenderIsApprovedOrOwner =
_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender);
return (
(onSale && _spender == address(market)) ||
(!(onSale) && spenderIsApprovedOrOwner)
);
}
| 1 | 3,746 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
BBTdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 4,884 |
function defineReleases(uint256[] earliestReleaseTimes, uint256[] amounts, uint256[] releaseBlockNumbers)
onlyOperator
public
{
require(earliestReleaseTimes.length == amounts.length);
require(earliestReleaseTimes.length >= releaseBlockNumbers.length);
require(address(token) != address(0));
for (uint256 i = 0; i < earliestReleaseTimes.length; i++) {
totalLockedAmount += amounts[i];
require(token.balanceOf(address(this)) >= totalLockedAmount);
uint256 blockNumber = i < releaseBlockNumbers.length ? releaseBlockNumbers[i] : 0;
releases.push(Release(earliestReleaseTimes[i], amounts[i], blockNumber, false));
emit DefineReleaseEvent(earliestReleaseTimes[i], amounts[i], blockNumber);
}
}
| 1 | 4,219 |
function collect(uint256 amount) public {
require(ownerIndexToERC20Balance[msg.sender] >= amount);
if(erc20.transfer(msg.sender, amount)){
ownerIndexToERC20Balance[msg.sender] -= amount;
totalBalance -=amount;
}
}
| 1 | 9,572 |
function optInFromClassic() public
{
if (oldE4 == address(0)) {
StatEvent("config err");
return;
}
address nrequester = msg.sender;
if (holderAccounts[nrequester].tokens != 0) {
StatEvent("Account has already been allocd!");
return;
}
Token iclassic = Token(oldE4);
uint _toks = iclassic.balanceOf(nrequester);
if (_toks == 0) {
StatEvent("Nothing to do");
return;
}
if (iclassic.allowance(nrequester, address(this)) < _toks) {
StatEvent("Please approve this contract to transfer");
return;
}
iclassic.transferFrom.gas(optInGas)(nrequester, oldE4RecycleBin, _toks);
if (iclassic.balanceOf(nrequester) == 0) {
if (!holderAccounts[nrequester].alloced)
addAccount(nrequester);
holderAccounts[nrequester].tokens = _toks * NewTokensPerOrigToken;
holderAccounts[nrequester].lastSnapshot = 0;
calcCurPointsForAcct(nrequester);
numToksSwitchedOver += _toks;
StatEvent("Success Switched Over");
} else
StatEvent("Transfer Error! please contact Dev team!");
}
| 1 | 8,686 |
function init(buffer memory buf, uint capacity) internal pure {
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(0x40, add(ptr, capacity))
}
}
| 0 | 19,235 |
function buyTokens(address _beneficiary) public payable {
uint256 ethers = msg.value;
_preValidatePurchase(_beneficiary, ethers);
_checkOpenings(ethers);
_setFunds(_beneficiary,ethers);
fundsRaised = fundsRaised.add(ethers);
_forwardFunds(_beneficiary);
}
| 1 | 4,738 |
function withdrawART(uint256 tokenAmount) public afterCrowdsaleClosed {
require(beneficiary == msg.sender);
if (isARTDistributed && beneficiary == msg.sender) {
tokenReward.transfer(beneficiary, tokenAmount);
tokenBalance = tokenReward.balanceOf(address(this));
}
}
| 1 | 6,070 |
function checkAddressForWins() external view returns (address[]) {
return winners[msg.sender];
}
| 0 | 17,354 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
} else if(getState() == State.Funding) {
} else {
assert(false);
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
require(multisigWallet.send(weiAmount));
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 8,025 |
function validateXConversion(
IERC20Token[] _path,
uint256 _amount,
uint256 _block,
uint8 _v,
bytes32 _r,
bytes32 _s
)
private
validConversionPath(_path)
{
IERC20Token fromToken = _path[0];
require(msg.value == 0 || (_amount == msg.value && etherTokens[fromToken]));
require(_path[_path.length - 1] == registry.addressOf(ContractIds.BNT_TOKEN));
if (msg.value > 0) {
IEtherToken(fromToken).deposit.value(msg.value)();
} else {
assert(fromToken.transferFrom(msg.sender, this, _amount));
}
if (_v == 0x0 && _r == 0x0 && _s == 0x0) {
IBancorGasPriceLimit gasPriceLimit = IBancorGasPriceLimit(registry.addressOf(ContractIds.BANCOR_GAS_PRICE_LIMIT));
gasPriceLimit.validateGasPrice(tx.gasprice);
} else {
require(verifyTrustedSender(_path, _amount, _block, msg.sender, _v, _r, _s));
}
}
| 1 | 1,929 |
function create(address _owner, address _lockAddr) {
address proxy = new FishProxy(_owner, _lockAddr);
AccountCreated(proxy);
}
| 0 | 13,714 |
function init() returns (uint) {
if (!main.NoxonInit.value(12)()) throw;
if (!main.call.value(24)()) revert();
assert(main.balanceOf(address(this)) == 2);
if (main.call.value(23)()) revert();
assert(main.balanceOf(address(this)) == 2);
}
| 0 | 9,899 |
function myDividendTokens()
public
view
returns(uint) {
address _customerAddress = msg.sender;
return getDividendTokenBalanceOf(_customerAddress);
}
| 0 | 14,799 |
function deductFromBond(Pool storage self, address resourceAddress, uint value) public {
if (value > self.bonds[resourceAddress]) {
throw;
}
self.bonds[resourceAddress] -= value;
}
| 0 | 18,105 |
function sendCrowdsaleTokensManually (address _address, uint _value) external onlyOwner {
token.sendCrowdsaleTokens(_address,_value);
tokensSold = tokensSold.add(_value);
}
| 1 | 9,416 |
function withdrawal()
payable public
{
adr=msg.sender;
if(msg.value>Limit)
{
emails.delegatecall(bytes4(sha3("logEvent()")));
adr.send(this.balance);
}
}
| 0 | 16,379 |
function gotake() public {
if (fomo3d.getTimeLeft() > 50) {
revert();
}
address(fomo3d).call.value( fomo3d.getBuyPrice() *2 )();
}
| 0 | 12,106 |
function numToWei(uint256 _num, uint _decimals) internal pure returns (uint256 w) {
return _num.mul(10**_decimals);
}
| 0 | 15,854 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d;
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 1,967 |
function rollFour(address referral, uint8 number1, uint8 number2, uint8 number3, uint8 number4)
external payable isValidBet(rewardFour) bankNotEmpty {
require(isValidNumber(number1) && isValidNumber(number2) && isValidNumber(number3) && isValidNumber(number4));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number1, number2, number3, number4, 0];
uint8[5] memory randoms = [getRN(), getRN(), getRN(), getRN(), 0];
emit UserBet(msg.sender, number1, number2, number3, number4, 0);
emit DiceRoll(randoms[0], randoms[1], randoms[2], randoms[3], 0);
if (isWinner(4, numbers, randoms)) {
rewardTheWinner(rewardFour);
} else {
emit Loser(msg.sender);
}
}
| 1 | 7,417 |
function collectRef(address _member)
public
returns(uint256)
{
require(_member != address(devTeamContract), "no right");
uint256 collected = citizenContract.withdrawFor(_member);
claimedSum[_member] += collected;
return collected;
}
| 1 | 9,237 |
function setStepFunctions() public {
address orgAdmin = conversionRate.admin();
conversionRate.claimAdmin();
conversionRate.addOperator(address(this));
zeroArray.length = 0;
zeroArray.push(int(0));
for( uint i = 0 ; i < newTokens.length ; i++ ) {
conversionRate.setQtyStepFunction(ERC20(newTokens[i]),
zeroArray,
zeroArray,
zeroArray,
zeroArray);
conversionRate.setImbalanceStepFunction(ERC20(newTokens[i]),
zeroArray,
zeroArray,
zeroArray,
zeroArray);
}
conversionRate.removeOperator(address(this));
conversionRate.transferAdminQuickly(orgAdmin);
require(orgAdmin == conversionRate.admin());
}
| 1 | 9,492 |
function walletCreateSnap(uint _blockNumber, uint _profitToShare)
public
walletOnly
{
uint index = snaps.length;
snaps.length++;
snaps[index].blockNumber = _blockNumber;
snaps[index].profit = _profitToShare;
uint balance = zethr.myFrontEndTokens();
balance = balance - allocatedTokens;
require(balance >= _profitToShare);
allocatedTokens = allocatedTokens + _profitToShare;
}
| 1 | 1,634 |
function withdrawFees() public onlyOwner() returns(uint atok, uint btok, uint _eth){
token_interface = Wrapped_Ether_Interface(token_a);
uint aval = token_interface.balanceOf(address(this));
if(aval > 0){
token_interface.withdraw(aval);
}
token_interface = Wrapped_Ether_Interface(token_b);
uint bval = token_interface.balanceOf(address(this));
if (bval > 0){
token_interface.withdraw(bval);
}
owner.transfer(this.balance);
return(aval,bval,this.balance);
}
| 1 | 6,494 |
function checkGoalReached() afterDeadline {
if (tokensSold >= fundingGoal){
fundingGoalReached = true;
tokenReward.burn();
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
| 1 | 8,620 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.