func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function executeProposal(uint proposalNumber, bytes transactionBytecode) {
Proposal p = proposals[proposalNumber];
if (now < p.votingDeadline
|| p.executed
|| p.proposalHash != sha3(p.recipient, p.amount, transactionBytecode))
throw;
uint quorum = 0;
uint yea = 0;
uint nay = 0;
for (uint i = 0; i < p.votes.length; ++i) {
Vote v = p.votes[i];
uint voteWeight = sharesTokenAddress.balanceOf(v.voter);
quorum += voteWeight;
if (v.inSupport) {
yea += voteWeight;
} else {
nay += voteWeight;
}
}
if (quorum <= minimumQuorum) {
throw;
} else if (yea > nay ) {
p.executed = true;
if (!p.recipient.call.value(p.amount * 1 ether)(transactionBytecode)) {
throw;
}
p.proposalPassed = true;
} else {
p.proposalPassed = false;
}
ProposalTallied(proposalNumber, yea - nay, quorum, p.proposalPassed);
}
| 1
| 3,889
|
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TBIZToken is ERC20, Ownable, Pausable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 internal initialSupply;
uint256 internal totalSupply_;
mapping(address => uint256) internal balances;
mapping(address => bool) public frozen;
mapping(address => mapping(address => uint256)) internal allowed;
event Burn(address indexed owner, uint256 value);
event Mint(uint256 value);
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
modifier notFrozen(address _holder) {
require(!frozen[_holder]);
_;
}
| 0
| 18,807
|
function addBonus(uint256 value, uint256 percentages) internal pure returns (uint256) {
return value.add(value.mul(percentages).div(100));
}
| 0
| 17,966
|
function hashSingleTotalInt256(
NahmiiTypesLib.SingleTotalInt256 memory singleTotalInt256)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(
singleTotalInt256.single,
singleTotalInt256.total
));
}
| 0
| 13,035
|
function rewardPayableDays() constant public returns (uint256) {
uint256 payableDays = rewardDays().sub(rewardDaysLeft());
if (payableDays == 0) {
payableDays = 1;
}
if (payableDays > rewardDays()) {
payableDays = rewardDays();
}
return payableDays;
}
| 0
| 11,733
|
function withdraw() public {
uint256 balance = address(this).balance;
ethpyramid.withdraw.gas(1000000)();
uint256 dividendsPaid = address(this).balance - balance;
dividends += dividendsPaid;
emit Dividends(dividendsPaid);
}
| 1
| 4,851
|
function getRefund() public {
uint refunds = 0;
for (uint i = 1; i <= totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refunds++;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refunds > 0) {
msg.sender.transfer(refunds * pricePerTicket);
}
}
| 0
| 17,700
|
function _getRandomNumber(uint _round) view private returns (uint256){
return uint256(keccak256(
participantsHashes[0],
participantsHashes[1],
participantsHashes[2],
participantsHashes[3],
participantsHashes[4],
msg.sender
)) % _round;
}
| 0
| 17,573
|
function StupidCrowdsale(uint256 _startTime, uint256 _endTime, address _wallet, address _token, address _tokenOwner) public {
require(_startTime < _endTime);
require(_wallet != address(0));
require(_token != address(0));
require(_tokenOwner != address(0));
startTime = _startTime;
endTime = _endTime;
wallet = _wallet;
tokenOwner = _tokenOwner;
token = StupidToken(_token);
}
| 0
| 13,872
|
function () payable public {
require(!crowdsaleClosed);
uint256 amount = msg.value;
uint256 tokenAmount = amount.mul(1000000);
tokenAmount = tokenAmount.div(tokenPrice);
require(token.balanceOf(this) >= tokenAmount);
amountRaised = amountRaised.add(amount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(amount);
tokenBalanceOf[msg.sender] = tokenBalanceOf[msg.sender].add(tokenAmount);
FundTransfer(msg.sender, amount, true);
token.transfer(msg.sender, tokenAmount);
recalcTokenPrice();
}
| 1
| 4,849
|
function rejectMail(uint256 mailIndex) public {
require(mails[mailIndex].sender == msg.sender);
require(mails[mailIndex].isRead == false);
require(mails[mailIndex].isRejected == false);
require(rejectConfig.isRejectEnabled() == true);
require(mails[mailIndex].createdTime + rejectConfig.minTimeForReject() < now);
mails[mailIndex].isRejected = true;
frozenBalance -= mails[mailIndex].paySum;
msg.sender.transfer(mails[mailIndex].paySum);
}
| 1
| 3,299
|
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
amount = invested[sender] * interest / 100 * (now - dateInvest[sender]) / 1 days;
if (msg.value == 0) {
if (amount >= address(this).balance) {
amount = (address(this).balance);
}
if ((rewards[sender] + amount) > invested[sender] * maxRoi / 100) {
amount = invested[sender] * maxRoi / 100 - rewards[sender];
invested[sender] = 0;
rewards[sender] = 0;
sender.send(amount);
return;
} else {
sender.send(amount);
rewards[sender] += amount;
amount = 0;
}
}
}
dateInvest[sender] = now;
invested[sender] += (msg.value + amount);
if (msg.value != 0) {
WhaleAddr.send(msg.value * whalefee / 100);
if (invested[sender] > invested[WhaleAddr]) {
WhaleAddr = sender;
}
}
}
| 0
| 18,352
|
function mintTimelocked(address _to, uint256 _amount, uint256 _releaseTime) onlyOwner canMint public returns (TokenTimelock) {
TokenTimelock timelock = new TokenTimelock(this, _to, _releaseTime);
mint(timelock, _amount);
return timelock;
}
| 0
| 18,866
|
function createPersonGen0(string _name, string _surname,uint64 _genes, bool _gender) external onlyCEO returns(uint256) {
return _birthPerson(_name, _surname ,_genes, _gender, false);
}
| 1
| 6,286
|
function () public payable {
require(now >= startDate && now <= endDate);
uint tokens;
if (now <= bonusEnds) {
tokens = msg.value * 1350;
} else {
tokens = msg.value * 1000;
}
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
}
| 0
| 12,988
|
function setInvestToken(address investTokenAddress) external onlyOwner valideAddress(investTokenAddress) {
investToken = InvestToken(investTokenAddress);
}
| 1
| 3,032
|
function release(ERC20 token) public {
for(uint i = 0; i < _beneficiary.length; i++) {
if(block.timestamp >= _unlocktime ){
token.transfer(_beneficiary[i], _amount[i].mul(10**18));
emit Released( _amount[i]);
_amount[i]=0;
}
}
}
| 1
| 3,903
|
function fillBuyOrder(uint _key) public {
uint order = orderBook.get(_key);
ORDER_TYPE orderType = ORDER_TYPE(order >> 254);
require(orderType == ORDER_TYPE.BUY, "This is not a buy order");
uint index = addressRegister(msg.sender);
require(index != (order << 2) >> 224, "You cannot fill your own order");
uint price = (order << 34) >> 145;
uint amount = (order << 145) >> 145;
uint orderFee = feeForOrder(price, amount);
require(feeBalances[index] >= orderFee, "You do not have enough deposited fees to fill this order");
uint cost = price.mul(amount).div(1 ether);
require(orderBook.remove(_key), "Map remove failed");
msg.sender.transfer(cost);
poolOwners.sendOwnershipFrom(msg.sender, addressRegistry[(order << 2) >> 224], amount);
if (orderFee > 0) {
feeBalances[index] = feeBalances[index].sub(orderFee);
uint totalFee = orderFee.mul(2);
totalFees = totalFees.sub(totalFee);
feeToken.transfer(poolOwners, totalFee);
}
emit OrderFilled(orderType, addressRegistry[(order << 2) >> 224], msg.sender, price, amount);
}
| 1
| 2,094
|
function setAStore(
string _appNickname,
address _address
)
public
onlyOwner
{
require(bytes(_appNickname).length > 0);
bytes32 _appNickname32 = keccak256(_appNickname);
require(_address != address(0));
ITweedentityStore _store = ITweedentityStore(_address);
require(_store.getAppNickname() == _appNickname32);
uint _appId = _store.getAppId();
require(appNicknames32[_appId] == 0x0);
appNicknames32[_appId] = _appNickname32;
appNicknames[_appId] = _appNickname;
__appIds[_appNickname] = _appId;
__stores[_appId] = Store(
ITweedentityStore(_address),
_address
);
}
| 1
| 4,469
|
function declareWinningOutcome(Outcome outcome) internal requireState(State.PreResolution) {
changeState(State.Resolved);
winningOutcome = outcome;
WinningOutcomeDeclared(outcome);
}
| 1
| 2,182
|
function verify(string sha256) constant returns (uint16,uint16,uint16,uint16,uint16,uint16) {
var timestamp = proofs[sha256];
if ( timestamp == 0 ){
return (0,0,0,0,0,0);
}else{
DateTime dt = DateTime(msg.sender);
uint16 year = dt.getYear(timestamp);
uint16 month = dt.getMonth(timestamp);
uint16 day = dt.getDay(timestamp);
uint16 hour = dt.getHour(timestamp);
uint16 minute = dt.getMinute(timestamp);
uint16 second = dt.getSecond(timestamp);
return (year, month,day,hour,minute,second);
}
}
| 0
| 15,099
|
function enterContest(uint32 _contestId, uint32[] _tokenIds) public payable whenNotPaused {
require (msg.sender != address(0));
require ((_contestId > 0) && (_contestId < contests.length));
Contest storage _contestToEnter = contests[_contestId];
require (_contestToEnter.status == ContestStatus.Active);
require(_contestToEnter.startTime > uint64(now));
require(msg.value >= _contestToEnter.entryFee);
uint32 maxEntries = uint32(_contestToEnter.maxMinEntries >> 32);
if (maxEntries > 0) {
require(_contestToEnter.teamIds.length < maxEntries);
}
uint32 _newTeamId = teamContract.createTeam(msg.sender, _tokenIds);
uint256 _teamIndex = _contestToEnter.teamIds.push(_newTeamId) - 1;
require(_teamIndex < 4294967295);
_contestToEnter.teamIdToIdx[_newTeamId] = uint32(_teamIndex);
teamIdToContestId[_newTeamId] = uint32(_contestId);
emit ContestEntered(_contestId, _newTeamId);
}
| 1
| 4,459
|
function removeFile(string memory _name) public isValid {
curators.checkRole(msg.sender, "authorized");
bytes32 hash = files[_name];
require(hash != bytes32(0));
files[_name] = bytes32(0);
emit FileRemoved(msg.sender, hash, _name);
}
| 0
| 13,509
|
function safe(bytes32 cup) public returns (bool) {
var pro = rmul(tag(), ink(cup));
var con = rmul(vox.par(), tab(cup));
var min = rmul(con, mat);
return pro >= min;
}
| 1
| 7,726
|
function ShutterToken() {
balances[msg.sender] = 10000000000000000000000000000;
totalSupply = 10000000000000000000000000000;
name = "Shutter Token";
decimals = 18;
symbol = "STT";
unitsOneEthCanBuy = 22222222;
fundsWallet = msg.sender;
}
| 0
| 17,403
|
function getInStake(uint256 round) public constant returns(uint256){
if(round == 0){
return roundStake[currentRoundCount];
}else{
return roundStake[round];
}
}
| 1
| 1,829
|
function setTokenContract(address _token) public onlyOwner {
require(_token != address(0));
token = GigToken(_token);
}
| 1
| 9,397
|
function mintExtendedTokens() internal {
uint extendedTokensPercent = bountyTokensPercent.add(devTokensPercent).add(advisorsTokensPercent).add(foundersTokensPercent);
uint extendedTokens = minted.mul(extendedTokensPercent).div(PERCENT_RATE.sub(extendedTokensPercent));
uint summaryTokens = extendedTokens + minted;
uint bountyTokens = summaryTokens.mul(bountyTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(bountyTokensWallet, bountyTokens);
uint advisorsTokens = summaryTokens.mul(advisorsTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(advisorsTokensWallet, advisorsTokens);
uint foundersTokens = summaryTokens.mul(foundersTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(foundersTokensWallet, foundersTokens);
uint devTokens = summaryTokens.mul(devTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(devTokensWallet, devTokens);
}
| 1
| 4,785
|
function redeemRewardedAxies(
address _receiver,
uint256 _quantity
)
external
onlyRedemptionAddress
whenInitialized
returns (uint256 _remainingQuantity)
{
_remainingQuantity = this.numRewardedAxies(_receiver, true).sub(_quantity);
if (_quantity > 0) {
_numDeductedRewardedAxies[_receiver] = _numDeductedRewardedAxies[_receiver].add(_quantity);
_totalDeductedRewardedAxies = _totalDeductedRewardedAxies.add(_quantity);
RewardedAxiesRedeemed(_receiver, _quantity);
}
}
| 0
| 17,205
|
function unTrackToken(address _addr, uint16 _position) onlyAdmin external {
require(isTokenTracked[_addr]);
require(trackedTokens[_position] == _addr);
ERC20(_addr).transfer(_addr, ERC20(_addr).balanceOf(address(this)));
trackedTokens[_position] = trackedTokens[trackedTokens.length-1];
delete trackedTokens[trackedTokens.length-1];
trackedTokens.length--;
}
| 1
| 2,245
|
function createTokens() public whenNotPaused payable {
require(msg.value >= minPrice);
uint stageIndex = currentStage();
multisigWallet.transfer(msg.value);
Stage storage stage = stages[stageIndex];
uint tokens = msg.value.mul(stage.price);
token.mint(this, tokens);
token.transfer(msg.sender, tokens);
totalTokensMinted = totalTokensMinted.add(tokens);
totalInvested = totalInvested.add(msg.value);
stage.invested = stage.invested.add(msg.value);
if(stage.invested >= stage.hardcap) {
stage.closed = now;
}
}
| 1
| 1,484
|
function decreaseApprovalPreSignedHashing(
address _token,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce
)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(bytes4(0x59388d78), _token, _spender, _subtractedValue, _fee, _nonce));
}
| 0
| 15,650
|
function readQuarterParticipantInfo(uint256 _quarterNumber)
public
view
returns (
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _totalEffectiveDGDPreviousQuarter
)
{
_minimalParticipationPoint = allQuartersInfo[_quarterNumber].minimalParticipationPoint;
_quarterPointScalingFactor = allQuartersInfo[_quarterNumber].quarterPointScalingFactor;
_reputationPointScalingFactor = allQuartersInfo[_quarterNumber].reputationPointScalingFactor;
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
}
| 1
| 7,337
|
function addMilestonesAndSeal(uint[] _etherAmounts, uint[] _tokenAmounts, uint[] _startTimes, uint[] _durations) public notSealed onlyAdmin {
require(_etherAmounts.length == _tokenAmounts.length);
require(_startTimes.length == _durations.length);
require(_durations.length == _etherAmounts.length);
for (uint i = 0; i < _etherAmounts.length; i++) {
totalEther = totalEther.add(_etherAmounts[i]);
totalToken = totalToken.add(_tokenAmounts[i]);
milestones.push(Milestone(_etherAmounts[i], _tokenAmounts[i], _startTimes[i],0,_durations[i],"",""));
}
sealTimestamp = now;
}
| 1
| 8,482
|
function optInFromClassic() public
{
if (oldE4 == address(0)) {
StatEvent("config err");
return;
}
address nrequester = msg.sender;
if (holderAccounts[nrequester].tokens != 0) {
StatEvent("Account has already has tokens!");
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;
}
if (msg.gas < optInXferGas + optInFcnMinGas)
throw;
iclassic.transferFrom.gas(optInXferGas)(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
| 3,647
|
function payWinners(uint32 _contestId, uint32 _payingStartingIndex, uint _numToPay, bool _isFirstPlace, uint32 _prevTies, uint32 _nextTies) public {
require((_contestId > 0) && (_contestId < contests.length));
Contest storage c = contests[_contestId];
require ((c.scoringOracleAddress == msg.sender) && (c.status == ContestStatus.Paying));
uint32[] memory localVars = new uint32[](2);
localVars[0] = _payingStartingIndex + 1;
if (c.winnersToPay + _prevTies > 0) {
uint32 s = (c.numWinners * (c.numWinners + 1)) / 2;
uint128 m = c.prizeAmount / uint128(s);
while ((c.winnersToPay + _prevTies > 0) && (_numToPay > 0)) {
uint128 totalPayout = 0;
uint32 totalNumWinnersWithTies = _prevTies;
if (_prevTies > 0) {
totalPayout = m*(_prevTies * c.winnersToPay + (_prevTies * (_prevTies + 1)) / 2);
}
localVars[1] = localVars[0];
uint32 numProcessedThisTime = 0;
while (teamContract.getScore(c.placeToWinner[localVars[1]]) == teamContract.getScore(c.placeToWinner[localVars[0]])) {
if (c.winnersToPay > 0) {
totalPayout += m*c.winnersToPay;
}
totalNumWinnersWithTies++;
numProcessedThisTime++;
if (c.winnersToPay > 0) {
c.winnersToPay--;
}
localVars[1]++;
_numToPay -= 1;
if ((_numToPay == 0) || (c.placeToWinner[localVars[1]] == 0)) {
break;
}
}
if (_isFirstPlace) {
totalPayout += c.prizeAmount - m * s;
}
_isFirstPlace = false;
if ((_numToPay == 0) && (_nextTies > 0)) {
totalNumWinnersWithTies += _nextTies;
if (_nextTies < c.winnersToPay) {
totalPayout += m*(_nextTies * (c.winnersToPay + 1) - (_nextTies * (_nextTies + 1)) / 2);
} else {
totalPayout += m*(c.winnersToPay * (c.winnersToPay + 1) - (c.winnersToPay * (c.winnersToPay + 1)) / 2);
}
}
uint128 payout = totalPayout / totalNumWinnersWithTies;
if (c.winnersToPay == 0) {
payout = c.remainingPrizeAmount / (numProcessedThisTime + _nextTies);
}
for (uint32 i = _prevTies; (i < (numProcessedThisTime + _prevTies)) && (c.remainingPrizeAmount > 0); i++) {
if (i == (totalNumWinnersWithTies - 1)) {
if ((c.winnersToPay == 0) && (_nextTies == 0)) {
payout = c.remainingPrizeAmount;
} else {
payout = totalPayout - (totalNumWinnersWithTies - 1)*payout;
}
}
if (payout > c.remainingPrizeAmount) {
payout = c.remainingPrizeAmount;
}
c.remainingPrizeAmount -= payout;
_authorizePayment(teamContract.getTeamOwner(c.placeToWinner[localVars[0]]), payout);
emit ContestTeamWinningsPaid(_contestId, c.placeToWinner[localVars[0]], payout);
localVars[0]++;
}
_prevTies = 0;
}
}
}
| 1
| 4,929
|
function nukeApps()onlyOwner public{
for(uint i = 0; i < OfficialApps.length; i++){
delete OfficialApps[i];
}
}
| 0
| 11,244
|
function stage4() private {
if ( amountPreSaleETHMD +
amountICOETHMD +
amountSpecialETHMD +
amountPreDonateETHMD +
amountManualSaleETHMD +
1000000 * 1000000000000000000 +
amountTransETHMD
<= MaxCoinsLimit15M ) {
balances[vault_community] += 1000000 * 1000000000000000000;
Transfer(address(0), vault_community, 1000000 * 1000000000000000000);
amountPreDonateETHMD += 1000000 * 1000000000000000000;
}
}
| 0
| 17,975
|
function mint(address _to, uint256 _amount) whenNotPaused onlyMinters notBlacklisted(msg.sender) notBlacklisted(_to) public returns (bool) {
require(_to != address(0));
require(_amount > 0);
uint256 mintingAllowedAmount = minterAllowed[msg.sender];
require(_amount <= mintingAllowedAmount);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount);
emit Mint(msg.sender, _to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
| 0
| 15,287
|
function __callback(bytes32 _queryId, string _result, bytes _proof) onlyOraclize {
betCount = add(betCount, 1);
uint betAmount = playerBetSize[_queryId];
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0 || _proof.length == 0) {
}
else {
uint playerNum = uint(sha3(_result)) % 2**(2*8) * 100 / ( 2**(2*8) );
if (playerHiLo[_queryId] == false ) {
if (playerNum + minimumNumber < ( 100 / 2 ) - edgeRange) {
LogBet(playerAddy[_queryId], playerHiLo[_queryId], playerNum + minimumNumber, betAmount, true);
playerAddy[_queryId].transfer((betAmount) * payoutMultiplier - standardFee);
totalPlayerWinnings = add(totalHouseWinnings,(betAmount) * payoutMultiplier);
}
else {
LogBet(playerAddy[_queryId], playerHiLo[_queryId], playerNum + minimumNumber, betAmount, false);
playerAddy[_queryId].transfer(1 wei);
totalHouseWinnings = add(totalHouseWinnings,(betAmount) * payoutMultiplier);
}
}
}
delete playerAddy[_queryId];
delete playerBetSize[_queryId];
delete playerHiLo[_queryId];
}
| 1
| 3,831
|
modifier onlyOwnerAllowed() {if (tx.origin != owner) throw; _}
function Token_Offer(address _tokenContract, address _tokenHolder, uint16 _price) {
owner = tx.origin;
tokenContract = TokenInterface(_tokenContract);
tokenHolder = _tokenHolder;
price = _price;
}
| 0
| 18,972
|
function _transfer(address _from, address _to, uint _amount) internal {
require (_to != 0x0);
require (balances[_from] > _amount);
require (balances[_to] + _amount > balances[_to]);
balances[_from] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
}
| 0
| 11,725
|
function __callback(bytes32 queryId, string result, bytes proof) public {
require(payoutCompleted == false);
require(msg.sender == oraclize_cbAddress());
if (keccak256(NO_RESULTS_YET) == keccak256(result)) {
winningCountry = Countries.None;
} else {
var resultSlice = result.toSlice();
resultSlice.split("\n".toSlice());
var winning_country_slice = resultSlice.split(" ".toSlice());
winning_country_string = winning_country_slice.toString();
if (strCompare(COUNTRY_NAMES[0], winning_country_string) == 0) {
winningCountry = Countries(0);
} else if (strCompare(COUNTRY_NAMES[1], winning_country_string) == 0) {
winningCountry = Countries(1);
} else if (strCompare(COUNTRY_NAMES[2], winning_country_string) == 0) {
winningCountry = Countries(2);
} else if (strCompare(COUNTRY_NAMES[3], winning_country_string) == 0) {
winningCountry = Countries(3);
} else if (strCompare(COUNTRY_NAMES[4], winning_country_string) == 0) {
winningCountry = Countries(4);
} else if (strCompare(COUNTRY_NAMES[5], winning_country_string) == 0) {
winningCountry = Countries(5);
} else if (strCompare(COUNTRY_NAMES[6], winning_country_string) == 0) {
winningCountry = Countries(6);
} else if (strCompare(COUNTRY_NAMES[7], winning_country_string) == 0) {
winningCountry = Countries(7);
}
}
if (winningCountry == Countries.None) {
if (now >= BET_RELEASE_DATE)
return releaseBets();
return pingOracle(PAYOUT_ATTEMPT_INTERVAL);
}
performPayout();
}
| 1
| 5,960
|
function burn(uint256 _value) public {
require(_value <= balances.balanceOf(msg.sender));
address burner = msg.sender;
balances.subBalance(burner, _value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
}
| 1
| 6,206
|
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber.add(BET_EXPIRATION_BLOCKS), "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets = lockedInBets.sub(diceWinAmount);
jackpotSize = jackpotSize.sub(jackpotFee);
sendFunds(bet.gambler, amount, amount);
}
| 0
| 19,127
|
function calNewTokens(uint256 contribution,string types) returns (uint256){
uint256 disc = totalDiscount(currentSupply,contribution,types);
uint256 CreatedTokens;
if(keccak256(types)==keccak256("ethereum")) CreatedTokens = SafeMath.mul(contribution,tokensPerEther);
else if(keccak256(types)==keccak256("bitcoin")) CreatedTokens = SafeMath.mul(contribution,tokensPerBTC);
uint256 tokens = SafeMath.add(CreatedTokens,SafeMath.div(SafeMath.mul(CreatedTokens,disc),100));
return tokens;
}
| 1
| 4,915
|
function NeuroToken() MyAdvancedToken(17500000, "NeuroToken", 0, "NRT") {
freezeTokens(17437000);
}
| 0
| 11,863
|
function decimals() external pure returns (uint256) {
return 0;
}
| 0
| 12,063
|
function manualSendTokens (address _address, uint _value) public onlyOwnerOrSubOwners {
token.sendCrowdsaleTokens(_address,_value.mul((uint)(10).pow(decimals))/tokenPrice);
ethCollected = ethCollected.add(_value);
}
| 0
| 16,046
|
function giftTokens(address _beneficiary, uint256 _giftAmount) external onlyOwner saleAllocatable {
require(_beneficiary != 0x0);
require(_giftAmount != 0);
require(blacklist[_beneficiary] == false);
require(bookkeep(_beneficiary, 0, _giftAmount));
TokenPurchase(msg.sender, _beneficiary, 0, _giftAmount);
token.mint(_beneficiary, _giftAmount);
}
| 0
| 16,042
|
function refundToWallet(address _wallet) public {
require( (now>icoEnd)&&(token.totalSupply()<icoSoftcap) );
uint value = balances[_wallet];
balances[_wallet] = 0;
_wallet.transfer(value);
}
| 1
| 9,109
|
function buyAnimalsFromAnimalFactory(string animalName, string animalDesc) public payable
{
require (!isContractPaused);
require(validPurchase());
require(msg.sender != 0x0);
uint gId=0;
if (msg.sender!=owner)
{
gId=1;
}
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.div(weiPerAnimal);
weiRaised = weiRaised.add(weiAmount);
uniqueAnimalId++;
animalObject = AnimalProperties({
id:uniqueAnimalId,
name:animalName,
desc:animalDesc,
upForSale: false,
priceForSale:0,
upForMating: false,
eggPhase: false,
priceForMating:0,
isBornByMating:false,
parentId1:0,
parentId2:0,
birthdate:now,
costumeId:0,
generationId:gId,
isSpecial:false
});
token.sendToken(msg.sender, uniqueAnimalId,animalName);
emit AnimalsPurchased(msg.sender, owner, weiAmount, tokens);
animalAgainstId[uniqueAnimalId]=animalObject;
totalBunniesCreated++;
owner.transfer(msg.value);
}
| 1
| 468
|
function highCompose(uint256 token1, uint256 token2, uint256 token3)
external
payable
whenNotPaused
{
require(msg.value >= 0.005 ether);
require(tokenContract.ownerOf(token1) == msg.sender);
require(tokenContract.ownerOf(token2) == msg.sender);
require(tokenContract.ownerOf(token3) == msg.sender);
require(!equipContract.isEquipedAny3(msg.sender, token1, token2, token3));
uint16 protoId;
uint16 quality;
uint16 pos;
uint16[12] memory fashionData = tokenContract.getFashion(token1);
protoId = fashionData[0];
quality = fashionData[1];
pos = fashionData[2];
require(quality == 3 || quality == 4);
fashionData = tokenContract.getFashion(token2);
require(protoId == fashionData[0]);
require(quality == fashionData[1]);
require(pos == fashionData[2]);
fashionData = tokenContract.getFashion(token3);
require(protoId == fashionData[0]);
require(quality == fashionData[1]);
require(pos == fashionData[2]);
uint256 seed = _rand();
uint16[9] memory attrs = _getFashionParam(seed, protoId, quality + 1, pos);
tokenContract.destroyFashion(token1, 1);
tokenContract.destroyFashion(token2, 1);
tokenContract.destroyFashion(token3, 1);
uint256 newTokenId = tokenContract.createFashion(msg.sender, attrs, 4);
_transferHelper(0.005 ether);
if (msg.value > 0.005 ether) {
msg.sender.transfer(msg.value - 0.005 ether);
}
ComposeSuccess(msg.sender, newTokenId, attrs[0], attrs[1], attrs[2]);
}
| 1
| 27
|
function claim() payable {
if(block.number < 3930000) throw;
uint256 pay_per_eth = (block.number - 3930000) / 10;
uint256 pay_to_claim = pay_per_eth * msg.value;
uint256 contract_pay_balance = token.balanceOf(address(this));
if((contract_pay_balance - total_pay_claimed) < pay_to_claim) throw;
pay_claimed[msg.sender] += pay_to_claim;
total_pay_claimed += pay_to_claim;
developer.transfer(msg.value);
}
| 1
| 8,242
|
function GoalToken() public {
totalSupply_ = 21 * 1000 * 10000 * 100000;
balances[msg.sender] = totalSupply_;
}
| 0
| 13,300
|
function removeSpriteFromSale (uint spriteId) {
if (broughtSprites[spriteId].owner != msg.sender) {
require (broughtSprites[spriteId].timesTraded == 0);
address kittyOwner = KittyCore(KittyCoreAddress).ownerOf(spriteId);
require (kittyOwner == msg.sender);
broughtSprites[spriteId].price = 1;
}
broughtSprites[spriteId].forSale = false;
}
| 1
| 4,147
|
function deposit(uint _amount) public {
require(_amount > 0);
require(token.transferFrom(msg.sender, this, _amount));
balances[msg.sender] = balances[msg.sender].add(_amount);
Deposit(msg.sender, _amount, balances[msg.sender]);
}
| 1
| 805
|
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalCards = totalSupply();
uint256 resultIndex = 0;
uint256 cardId;
for (cardId = 0; cardId <= totalCards; cardId++) {
if (cardIndexToOwner[cardId] == _owner) {
result[resultIndex] = cardId;
resultIndex++;
}
}
return result;
}
}
| 0
| 19,150
|
function mintToFounders() onlyOwner whenNotMintingFounders public returns (bool) {
mintToFounders(t_ImmlaTokenDepository, 52000 * 1 ether, 2);
mintToFounders(t_ImmlaTokenDepository2, 0, 2);
mintToFounders(t_ImmlaBountyTokenDepository, 0, 2);
mintToFounders(t_Andrey, 525510849836086000000000, 1);
mintToFounders(t_Michail, 394133137377065000000000, 1);
mintToFounders(t_Slava, 394133137377065000000000, 1);
mintToFounders(t_Andrey2, 284139016853060000000000, 2);
mintToFounders(t_Michail2, 213104262639795000000000, 2);
mintToFounders(t_Slava2, 213104262639795000000000, 2);
mintingFoundersFinish = true;
return true;
}
| 1
| 8,623
|
function enableTokensTransfer() external managerOnly {
CRET.defrostTokens();
}
| 0
| 14,224
|
function validPurchase() internal constant returns (bool) {
bool nonZeroPurchase = msg.value != 0;
bool minAmount = msg.value >= minimumParticipationAmount;
bool withinCap = weiRaised.add(msg.value) <= cap;
return nonZeroPurchase && minAmount && !isFinalized && withinCap;
}
| 0
| 19,072
|
function claimTokens()
public
timedTransitions
onlyWhitelisted(msg.sender)
atStage(Stages.ClaimingStarted)
{
require(!claimedStatus[msg.sender], "User already claimed");
require(gtxRecord.lockRecords(), "gtx records record updating must be locked");
require(gtxPresale.lockRecords(), "presale record updating must be locked");
fundsClaimed = fundsClaimed.add(bids[msg.sender]);
uint256 accumulatedTokens = calculateTokens(msg.sender);
bids[msg.sender] = 0;
totalTokens[msg.sender] = 0;
claimedStatus[msg.sender] = true;
require(ERC20.transfer(msg.sender, accumulatedTokens), "transfer failed");
emit ClaimedTokens(msg.sender, accumulatedTokens);
assert(bids[msg.sender] == 0);
}
| 1
| 6,707
|
function startRound() private
{
require(games[round].ended == true);
uint256 crystalsLastRound = games[round].crystals;
uint256 prizePoolLastRound= games[round].prizePool;
round = round + 1;
uint256 endTime = now + HALF_TIME;
uint256 engineerPrizePool = getEngineerPrizePool();
uint256 prizePool = SafeMath.div(SafeMath.mul(engineerPrizePool, 5),100);
if (prizePool >= PRIZE_MAX) prizePool = PRIZE_MAX;
Engineer.claimPrizePool(address(this), prizePool);
if (crystalsLastRound <= 0) prizePool = SafeMath.add(prizePool, prizePoolLastRound);
games[round] = Game(round, 0, prizePool, endTime, false);
}
| 1
| 5,671
|
function buyTokens(address beneficiary) public payable whenNotPaused {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 returnWeiAmount;
uint rate = getRate();
assert(rate > 0);
uint256 tokens = weiAmount.mul(rate);
uint256 newIcoSoldTokens = icoSoldTokens.add(tokens);
if (newIcoSoldTokens > icoCap) {
newIcoSoldTokens = icoCap;
tokens = icoCap.sub(icoSoldTokens);
uint256 newWeiAmount = tokens.div(rate);
returnWeiAmount = weiAmount.sub(newWeiAmount);
weiAmount = newWeiAmount;
}
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary, tokens);
icoSoldTokens = newIcoSoldTokens;
if (returnWeiAmount > 0){
msg.sender.transfer(returnWeiAmount);
}
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1
| 1,143
|
function ExternalCurrencyPrice()
public
{
owner = tx.origin;
}
| 0
| 18,745
|
function setProposalDraftPass(bytes32 _proposalId, bool _result)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].draftVoting.passed = _result;
if (_result) {
proposalsByState[PROPOSAL_STATE_DRAFT].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_MODERATED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_MODERATED;
} else {
closeProposalInternal(_proposalId);
}
}
| 1
| 2,737
|
function allocateReserveCompanyTokens() {
require(msg.sender==founder);
uint tokens = 0;
if(block.timestamp > month6companyUnlock && !allocated6Months)
{
allocated6Months = true;
tokens = safeDiv(totalTokensCompany, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month12companyUnlock && !allocated12Months)
{
allocated12Months = true;
tokens = safeDiv(totalTokensCompany, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month18companyUnlock && !allocated18Months)
{
allocated18Months = true;
tokens = safeDiv(totalTokensCompany, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month24companyUnlock && !allocated24Months)
{
allocated24Months = true;
tokens = safeDiv(totalTokensCompany, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else revert();
AllocateTokens(msg.sender);
}
| 0
| 15,288
|
constructor () public
{
owner = msg.sender;
GameRoundData.extraData[0] = 20;
GameRoundData.extraData[1] = 0;
GameRoundData.extraData[2] = uint32((3600*1) / 15);
GameRoundData.extraData[3] = uint32((3600*24) / 15);
if ( address(this).balance > 0)
{
owner.transfer( address(this).balance );
}
}
| 0
| 9,841
|
function getInitialTerrain(uint x, uint y) public pure returns (bytes32) {
return sha256(x, y);
}
| 0
| 15,487
|
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.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);
if (!address(Team_Forwarder).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _p3d.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
{
if (!address(Team_Forwarder).call.value(_p3d)(bytes4(keccak256("deposit()")))){
_res = _p3d.add(_res);
}
}
_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_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1
| 7,138
|
function setXPAAssets(
address XPAAssets_
)
public
onlyOperator
{
require(
XPAAssets_ != address(0)
);
if(
XPAAssets_ == XPAAssets &&
candidateXPAAssets != address(0)
) {
emit eCancelNominatingXPAAssets(candidateXPAAssets);
candidateXPAAssets = address(0);
candidateTillXPAAssets = 0;
} else if(
XPAAssets == address(0)
) {
emit eChangeXPAAssets(address(0), XPAAssets_);
XPAAssets = XPAAssets_;
} else if(
XPAAssets_ != candidateXPAAssets &&
candidateTillXPAAssets + 86400 * 7 < block.timestamp
) {
emit eNominatingXPAAssets(XPAAssets_);
candidateXPAAssets = XPAAssets_;
candidateTillXPAAssets = block.timestamp + 86400 * 7;
} else if(
XPAAssets_ == candidateXPAAssets &&
candidateTillXPAAssets < block.timestamp
) {
emit eChangeXPAAssets(XPAAssets, candidateXPAAssets);
dismissTokenOperator(XPAAssets);
assignTokenOperator(candidateXPAAssets);
XPAAssets = candidateXPAAssets;
candidateXPAAssets = address(0);
}
}
| 1
| 5,995
|
function withdrawFunds() onlyOwner returns (bool success)
{
owner.call.gas(200000).value(this.balance)();
return true;
}
| 0
| 16,860
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, H3Ddatasets.EventReturns memory _eventData_)
private
returns(H3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(10)) / 100;
uint256 _p3d = 0;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit H3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
TeamDreamHub_.deposit.value(_com)();
return(_eventData_);
}
| 0
| 13,474
|
function disapproveInvestor(address toDisapprove) public onlyOwner {
delete isInvestorApproved[toDisapprove];
emit Disapproved(toDisapprove);
}
| 0
| 14,493
|
function finishElections(uint _iterations) {
require(elections[nextElectionIndex - 1].endBlock < block.number);
require(!elections[nextElectionIndex - 1].electionsFinished);
uint curentVotes;
uint nextCandidateId = elections[nextElectionIndex - 1].idProcessed;
for (uint cnt = 0; cnt < _iterations; cnt++) {
curentVotes = elections[nextElectionIndex - 1].candidateVotes[nextCandidateId];
if (curentVotes > elections[nextElectionIndex - 1].numOfMaxVotes) {
elections[nextElectionIndex - 1].maxVotes = elections[nextElectionIndex - 1].candidateIndex[nextCandidateId];
elections[nextElectionIndex - 1].numOfMaxVotes = curentVotes;
}
nextCandidateId++;
}
elections[nextElectionIndex - 1].idProcessed = nextCandidateId;
if (elections[nextElectionIndex - 1].candidateIndex[nextCandidateId] == 0x0) {
creditCEO = elections[nextElectionIndex - 1].maxVotes;
elections[nextElectionIndex - 1].electionsFinished = true;
if (elections[nextElectionIndex - 1].numOfMaxVotes == 0) {
elections[nextElectionIndex].startBlock = block.number;
elections[nextElectionIndex].endBlock = block.number + blocksPerMonth;
elections[nextElectionIndex].totalCrbSupply = creditBitContract.totalSupply();
nextElectionIndex++;
}
}
}
| 1
| 8,289
|
function revokeUnicorn(uint _unicornId) whenNotPaused public {
require(unicornToken.owns(msg.sender, _unicornId));
_deleteOffer(_unicornId);
}
| 0
| 15,972
|
function fallback() internal minInvestLimited(msg.value) returns(uint) {
require(now >= start && now < endSaleDate());
return mintTokensByETH(msg.sender, msg.value);
}
| 1
| 3,742
|
function settleBet(uint[] combinationParameter, uint reveal) external {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (bet.amount != 0);
require (block.number <= bet.placeBlockNumber.add(BetExpirationBlocks));
bytes32 _entropy = keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
reveal,
blockhash(combinationParameter[uint8(SettleParam.LuckySeed)])
)
)
),
blockhash(block.number)
)
)
),
blockhash(block.timestamp)
)
);
uint totalAmount = 0;
uint totalTokenAmount = 0;
uint totalJackpotWin = 0;
(totalAmount,totalTokenAmount,totalJackpotWin) = runRotateTime(combinationParameter,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))));
if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
emit JackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
jackpotSize = uint128(jackpotSize.sub(totalJackpotWin));
}else if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 1) {
emit TokenJackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
tokenJackpotSize = uint128(tokenJackpotSize.sub(totalJackpotWin));
}
emit BetRelatedData(bet.gambler,bet.amount,totalAmount,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))),uint8(combinationParameter[uint8(SettleParam.Uplimit)]),uint8(combinationParameter[uint8(SettleParam.RotateTime)]));
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
if (totalAmount != 0){
sendFunds(bet.gambler, totalAmount , totalAmount);
}
if (totalTokenAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalTokenAmount);
emit TokenPayment(bet.gambler, totalTokenAmount);
}
}
}else if(combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
if (totalAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalAmount);
emit TokenPayment(bet.gambler, totalAmount);
}
}
}
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
lockedInBets = lockedInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
} else if (combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
lockedTokenInBets = lockedTokenInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
}
bet.amount = 0;
if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 0) {
jackpotSize = jackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}else if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 1) {
tokenJackpotSize = tokenJackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}
}
| 1
| 83
|
function NewtonTree() {
balances[msg.sender] = 10000000000000;
totalSupply = 10000000000000;
name = "NewtonTree";
decimals = 5;
symbol = "NTT";
fundsWallet = 0xf3E22529D348a12b7976671A0A3770b7D44068d9;
}
| 0
| 16,870
|
function sellWeapon(uint _weaponId, uint _sellPrice) ifSaleLive onlyOwnerOrOperator(_weaponId) public {
require( ! isOnSale[_weaponId], '4');
address weaponOwner = weaponTokenize.getOwnerOf(_weaponId);
uint _commssion = calculateCommission(_sellPrice);
item memory testItem = item(_sellPrice, _commssion, weaponOwner);
putWeaponOnSale(_weaponId, testItem);
emit OrderPlaced(weaponOwner, msg.sender, _weaponId, _sellPrice);
}
| 1
| 925
|
function hasEnded() public constant returns (bool) {
return block.timestamp < time0 || (block.timestamp > time2 && block.timestamp < time3) || block.timestamp > time7;
}
| 0
| 17,292
|
function getTotalCoinsSold() public view returns(uint _coinsSold) {
return totalCoinsSold;
}
| 0
| 15,961
|
function pullRipCord()
isAdministrator
public
{
uint players = playerList.length;
for (uint i = 0; i < players; i++) {
address _toRefund = playerList[i];
_toRefund.send(0.19171 ether);
emit RipcordRefund(_toRefund);
}
selfdestruct(administrator);
}
| 0
| 15,203
|
function processPurchase(address referrer) payable public {
if (!active) { revert(); }
if (msg.value == 0) { revert(); }
uint256 purchasedAmount = msg.value.div(priceDiv);
if (purchasedAmount == 0) { revert(); }
if (purchasedAmount > hardCap - sold) { revert(); }
sold += purchasedAmount;
treasury.transfer(msg.value);
ERC223 token = ERC223(tokenAddress);
token.transfer(msg.sender, purchasedAmount);
Purchase(msg.sender, purchasedAmount);
processReferral(referrer, purchasedAmount, msg.value);
}
| 1
| 8,382
|
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract SuperEdge is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "SuperEdge";
string public constant symbol = "ECT";
uint public constant decimals = 8;
uint256 public totalSupply = 2000000000e8;
uint256 public totalDistributed = 120000000e8;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value = 15000e8;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0
| 16,814
|
function buyForHackerGold(uint hkgValue) onlyBeforeEnd
returns (bool success) {
if (msg.sender != virtualExchangeAddress) throw;
address sender = tx.origin;
uint tokensQty = hkgValue * hkgPrice;
votingRights[sender] +=tokensQty;
preferedQtySold += tokensQty;
collectedHKG += hkgValue;
transferFrom(this,
virtualExchangeAddress, tokensQty);
transfer(sender, tokensQty);
BuyForHKGTransaction(sender, preferedQtySold, totalSupplyVar, hkgPrice, tokensQty);
return true;
}
| 0
| 16,090
|
function addBuyer(address clientAddress, uint256 tokensCount) public onlyOwner {
require( (clientAddress != address(0)) && (tokensCount > 0) );
require(buyersBalances[clientAddress] == buyPrice);
require(!insurancesMap[clientAddress].exists);
require(getTokensCount(clientAddress) >= tokensCount);
insurancesMap[clientAddress] = ClientInsurance(tokensCount, false, true, false);
}
| 1
| 2,536
|
function getTotalAmountVested(VestingSchedule vestingSchedule)
internal
view
returns (uint)
{
if (block.timestamp >= vestingSchedule.endTimeInSec) return vestingSchedule.totalAmount;
uint timeSinceStartInSec = safeSub(block.timestamp, vestingSchedule.startTimeInSec);
uint totalVestingTimeInSec = safeSub(vestingSchedule.endTimeInSec, vestingSchedule.startTimeInSec);
uint totalAmountVested = safeDiv(
safeMul(timeSinceStartInSec, vestingSchedule.totalAmount),
totalVestingTimeInSec
);
return totalAmountVested;
}
| 0
| 13,089
|
function SafeGift(uint256 _totalSupply, string _tokenName, string _tokenSymbol) public{
owner = msg.sender;
totalSupply = _totalSupply;
balances[owner] = totalSupply;
name = _tokenName;
symbol = _tokenSymbol;
}
| 0
| 15,367
|
function unFreezeAccount(address _target) onlyOwner public {
require(_target != address(0));
require(frozenAccount[_target] != false);
frozenAccount[_target] = false;
emit UnFreeze(_target);
}
| 0
| 16,408
|
function refund(uint _value) minCapNotReached public {
if (_value != backers[msg.sender].utcoinSent) throw;
utcoin.transferFrom(msg.sender, address(this), _value);
if (!utcoin.burn(_value)) throw ;
uint ETHToSend = backers[msg.sender].weiReceived;
backers[msg.sender].weiReceived=0;
if (ETHToSend > 0) {
asyncSend(msg.sender, ETHToSend);
}
}
| 1
| 6,141
|
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 0
| 15,164
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, ExitScamsdatasets.EventReturns memory _eventData_)
private
returns(ExitScamsdatasets.EventReturns)
{
uint256 _com = _eth * 39 / 1000;
uint256 _aff = _eth / 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit ExitScamsevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community1.transfer(_com/2);
community2.transfer(_com/2);
return(_eventData_);
}
| 0
| 15,615
|
function harvest(address farmer) internal {
recycle(farmer);
var list = fields[farmer];
for (uint i = empties[farmer]; i < list.length; i++) {
var elapsed = block.timestamp - list[i].sowed;
if (elapsed >= growth) {
if (elapsed - growth < decay) {
var harvested = (2 * list[i].potatoes * (decay-elapsed+growth) + decay-1) / decay;
var rotten = 2 * list[i].potatoes - harvested;
cellars[farmer] += harvested;
Transfer(this, farmer, harvested);
if (rotten > 0) {
trashes[farmer] += rotten;
Transfer(this, 0, rotten);
}
} else {
trashes[farmer] += 2 * list[i].potatoes;
Transfer(this, 0, 2 * list[i].potatoes);
}
empties[farmer]++;
}
}
if (empties[farmer] > 0 && empties[farmer] == list.length) {
delete empties[farmer];
delete fields[farmer];
}
}
| 0
| 18,729
|
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
super._updatePurchasingState(_beneficiary, _weiAmount, _tokenAmount);
}
| 1
| 2,798
|
function setFee(uint256 _fee) onlyOwner {
fee = _fee;
}
| 0
| 11,014
|
function initialize(address _founder, address _bounty) onlyManager {
assert(currentStage != Stage.Init);
assert(_founder != 0x0);
assert(_bounty != 0x0);
require(!setFounder);
require(!setBounty);
founder = _founder;
bountyOwner = _bounty;
VINToken.emitTokens(_bounty, totalBountyTokens);
setFounder = true;
setBounty = true;
currentStage = Stage.Init;
}
| 1
| 8,031
|
function uint256ToString(uint256 num) public pure returns(string memory){
if (num == 0){
return "0";
}
uint256 numLen = amountOfZeros(num, 10) + 1;
bytes memory result = new bytes(numLen);
while(num != 0){
numLen -= 1;
result[numLen] = byte(uint8((num - (num / 10 * 10)) + 48));
num /= 10;
}
return string(result);
}
| 0
| 16,341
|
function addContributor(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
registry.addContributor(_contributor, _amount, _amusd, _tokens, _quote);
ethRaised += _amount;
usdRaised += _amusd;
totalTokens += _tokens;
ContributionAddedManual(_contributor, ethRaised, usdRaised, totalTokens, _quote);
}
| 1
| 5,736
|
function FaceblockCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet)
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
}
| 0
| 15,388
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.