func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function setMigrationAgent (address _address) public onlyMigrationMaster migrationAgentNotSet {
require(_address != address(0));
super.setMigrationAgent(_address);
}
| 0 | 9,832 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, J3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit J3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1 | 6,979 |
function placeETHBid(uint8 _siteId) onlyRunning payable external validETHSiteId(_siteId) {
if (msg.sender.isContract()) revert();
if (msg.value < bidETHMin) revert();
uint index = 0;
totalBid += 1;
BiddingInfo storage bid = bids[totalBid];
bid.bidder = msg.sender;
bid.bidId = totalBid;
bid.amount = msg.value;
bid.time = block.timestamp;
bid.siteId = _siteId;
uint32[] storage siteBids = sites[_siteId];
if (siteBids.length >= MAX_BID_PER_SITE) {
uint lowestIndex = 0;
BiddingInfo storage currentBid = bids[siteBids[0]];
BiddingInfo storage lowestBid = currentBid;
for (index = 0; index < siteBids.length; index++) {
currentBid = bids[siteBids[index]];
if (currentBid.bidder == msg.sender) {
revert();
}
if (lowestBid.amount == 0 || currentBid.amount < lowestBid.amount || (currentBid.amount == lowestBid.amount && currentBid.bidId > lowestBid.bidId)) {
lowestIndex = index;
lowestBid = currentBid;
}
}
if (msg.value < lowestBid.amount + bidETHIncrement)
revert();
siteBids[lowestIndex] = totalBid;
lowestBid.bidder.transfer(lowestBid.amount);
} else {
for (index = 0; index < siteBids.length; index++) {
if (bids[siteBids[index]].bidder == msg.sender)
revert();
}
siteBids.push(totalBid);
}
EventPlaceBid(msg.sender, _siteId, totalBid, msg.value);
}
| 0 | 11,824 |
function votePrice(uint x,bool v){
Vote V=votes[x];
var(a,b,c,d,e) = Ark.getLastPrice(x);
if(check(x)&&(!(V.voters[msg.sender]))&&(x<=5)&&(a<=max)&&(a>=min)){
V.voters[msg.sender]=true;
if(v){V.up++;
if(V.up>thresold[2]){
uint u=a+(a/10);
controller.setPrice(x,u);
lastblock[x]=block.number;
votes[x]=Vote({up:0,down:0});
}
}else{
V.down++;
if(V.down>thresold[2]){
uint z=a-(a/10);
controller.setPrice(x,z);
lastblock[x]=block.number;
votes[x]=Vote({up:0,down:0});
}
}
}else{throw;}
}
| 1 | 2,376 |
function TilcoinStorage() public {
addManager(msg.sender);
addManager(0x209eba96c917871f78671a3ed3503ecc4144495c);
}
| 0 | 11,483 |
function makeBet(uint8 n1, uint8 n2, uint8 n3, uint8 n4, uint8 n5, uint8 n6, address _partner)
payable returns (bool) {
require(msg.value == ticketPrice);
bytes3 uBet = toBytes(n1, n2, n3, n4, n5, n6);
Bet memory pBet = Bet({player: msg.sender, bet: uBet});
TicketBet memory tBet = TicketBet({bet: uBet, isPayed: false});
tickets[msg.sender][gameNext].push(tBet);
gameBets[gameNext].push(pBet);
weiRaised[gameNext] += ticketPrice;
Ticket(gameNext, msg.sender, uBet);
champion.buyTicket(msg.sender);
if (_partner != 0x0 && partner[msg.sender] == 0x0) {
addPartner(_partner, msg.sender);
}
return true;
}
| 1 | 6,511 |
function PLANETAGROToken () {
owner = msg.sender;
}
| 0 | 13,279 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(Bank).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
| 0 | 18,657 |
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
| 0 | 14,473 |
function () payable {
if(isFinalized && msg.value <= 0) throw;
if(block.number < icoStartBlock) throw;
if(block.number > icoEndBlock) throw;
etherBlance[msg.sender] += msg.value;
uint256 val = msg.value;
uint256 bonus = calcBonus(val);
uint256 level2bonus = calcLevel2Bonus(val);
uint256 tokens = msg.value.add(level2bonus).add(bonus).mul(exchangeRate);
uint256 checkedSupply = totalSupply.add(tokens);
totalSupply = checkedSupply;
bool transfer = token.transferFrom( token.getOwner(),msg.sender, tokens);
if(!transfer){
totalSupply = totalSupply.sub(tokens);
throw;
}
}
| 1 | 5,439 |
function findBoundingOrders(Order.Types _type, uint256 _price, bytes32 _bestOrderId, bytes32 _worstOrderId, bytes32 _betterOrderId, bytes32 _worseOrderId) public returns (bytes32, bytes32) {
IOrders _orders = IOrders(controller.lookup("Orders"));
if (_bestOrderId == _worstOrderId) {
if (_bestOrderId == bytes32(0)) {
return (bytes32(0), bytes32(0));
} else if (_orders.isBetterPrice(_type, _price, _bestOrderId)) {
return (bytes32(0), _bestOrderId);
} else {
return (_bestOrderId, bytes32(0));
}
}
if (_betterOrderId != bytes32(0)) {
if (_orders.getPrice(_betterOrderId) == 0) {
_betterOrderId = bytes32(0);
} else {
_orders.assertIsNotBetterPrice(_type, _price, _betterOrderId);
}
}
if (_worseOrderId != bytes32(0)) {
if (_orders.getPrice(_worseOrderId) == 0) {
_worseOrderId = bytes32(0);
} else {
_orders.assertIsNotWorsePrice(_type, _price, _worseOrderId);
}
}
if (_betterOrderId == bytes32(0) && _worseOrderId == bytes32(0)) {
return (descendOrderList(_type, _price, _bestOrderId));
} else if (_betterOrderId == bytes32(0)) {
return (ascendOrderList(_type, _price, _worseOrderId));
} else if (_worseOrderId == bytes32(0)) {
return (descendOrderList(_type, _price, _betterOrderId));
}
if (_orders.getWorseOrderId(_betterOrderId) != _worseOrderId) {
return (descendOrderList(_type, _price, _betterOrderId));
} else if (_orders.getBetterOrderId(_worseOrderId) != _betterOrderId) {
return (ascendOrderList(_type, _price, _worseOrderId));
}
return (_betterOrderId, _worseOrderId);
}
| 0 | 10,759 |
function issueTokensInternal(address _to, uint _tokens) internal {
if((icoTokensSold + _tokens)>ICO_TOKEN_SUPPLY_LIMIT){
throw;
}
mntToken.issueTokens(_to,_tokens);
icoTokensSold+=_tokens;
LogBuy(_to,_tokens);
}
| 1 | 6,493 |
function buyTokens(address beneficiary) private {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 discount = ((toBeRaised*10000)/HARD_CAP)*15;
uint256 tokens;
weiRaised = weiRaised.add(weiAmount);
toBeRaised = toBeRaised.sub(weiAmount);
uint commission;
uint extra;
uint premium;
if (register.approved(beneficiary)) {
(commission, extra) = register.getBonuses(beneficiary);
if (extra > 0) {
discount += extra*10000;
}
tokens = howMany(msg.value, discount);
if (commission > 0) {
premium = tokens.mul(commission).div(100);
token.mint(BOUNTY, premium);
}
} else {
extra = register2.getBonuses(beneficiary);
if (extra > 0) {
discount = extra*10000;
tokens = howMany(msg.value, discount);
}
}
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
tokensSold += tokens + premium;
forwardFunds();
assert(token.totalSupply() <= maxTokens);
}
| 1 | 8,964 |
function tokenFallbackExchange(address _from, uint _value, uint _choose) onlyNami public returns (bool success) {
require(_choose <= 2);
if (_choose == 0) {
require(_value >= minNac);
emit Deposit(_from, _value, now);
} else if(_choose == 1) {
require(_value >= minNac && NLFunds[currentRound].isOpen == true);
membersNLF[currentRound][_from].fciNLF = membersNLF[currentRound][_from].fciNLF.add(_value);
NLFunds[currentRound].currentNAC = NLFunds[currentRound].currentNAC.add(_value);
emit InvestToNLF(_from, _value, now);
} else if(_choose == 2) {
require(_value >= minNac);
emit PlaceBuyFciOrder(_from, _value, now);
}
return true;
}
| 1 | 5,510 |
function setMinBetPerTx(uint256 minBet) public {
require(msg.sender == OWNER && minBet > 1000);
MINBET_perTX = minBet;
}
| 1 | 5,330 |
function getCurrentBonusRate() internal returns (uint8) {
if (getState() == State.Acquiantances) {
return 40;
}
if (getState() == State.PreSale) {
return 20;
}
if (getState() == State.CrowdFund) {
return 0;
} else {
return 0;
}
}
| 0 | 17,585 |
function getVault() public view returns (RoundVault) {
return vault;
}
| 1 | 4,531 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view{
require(_beneficiary != address(0),"Invalid address");
require(_weiAmount >= minValue,"Min amount is 0.005 ether");
require(currentState != State.Refunding, "Only for CrowdSale and Work stage.");
}
| 0 | 9,866 |
function getImpactDonor(string outcome, uint index) returns(address) {
return impact[outcome].addresses[index];
}
| 0 | 15,587 |
function enter() {
if (msg.value < 1 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 20 ether) {
msg.sender.send(msg.value - 20 ether);
amount = 20 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 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 16,749 |
function donate(address charity) public onlyOwner validAddress(charity){
uint value = charityPot;
charityPot = 0;
charity.transfer(value);
emit Withdrawal(1, charity, value);
}
| 0 | 10,142 |
function withdrawPrize() private {
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance)
prizeAmount = balance;
uint prize = prizeAmount;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
}
| 0 | 12,089 |
function get_orderAddress(address _address,uint _expire_day,uint _userdata,uint _pixiu, uint _wei) constant returns (address){
uint256 storeid = shopStoreId[_address];
uint160 result = uint152(0xffffffff<<120) + uint120((_expire_day * 86400 + now)<<88) + uint88(storeid<<64);
uint _zero = 0;
uint256 _amount2 = _pixiu * 10 ** 6 + _wei;
uint256 _amount = _amount2;
while(_amount2 % 10 == 0){
_amount2 /= 10;
_zero++;
}
_userdata = _userdata<<24;
_userdata += _amount;
result += uint64(_userdata<<8);
result += uint8(0x30+_zero);
uint8 crc = uint8(sha256(uint152(result) ));
return address((result << 8) + crc);
}
| 0 | 16,531 |
function hasOpened() public view returns (bool) {
return (openingTime < block.timestamp && block.timestamp < closingTime);
}
| 0 | 11,280 |
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
| 0 | 18,361 |
function checkIfRefundAvailable(bytes32 _username) public constant returns (bool) {
return ((lastTip[msg.sender][_username] < (now - 2 weeks)) &&
(tips[msg.sender][_username] > 0));
}
| 1 | 7,788 |
function createTokens() whenNotPaused isUnderHardCap saleIsOn payable {
require(msg.value >= 100000000000000000);
uint milestoneIndex = currentMilestone();
Milestone storage milestone = milestones[milestoneIndex];
if(!isSoftcapOn) {
multisigWallet.transfer(msg.value);
}
invested = invested.add(msg.value);
uint tokens = msg.value.mul(1 ether).div(price);
uint bonusTokens = tokens.mul(milestone.bonus).div(percentRate);
uint tokensWithBonus = tokens.add(bonusTokens);
token.mint(this, tokensWithBonus);
token.transfer(msg.sender, tokensWithBonus);
balances[msg.sender] = balances[msg.sender].add(msg.value);
}
| 1 | 3,456 |
function unlockTokens() public returns (bool) {
require(holderList[msg.sender].isActive);
require(!holderList[msg.sender].withdrawed);
require(now >= holderList[msg.sender].holdPeriodTimestamp);
OppToken.transfer(msg.sender, holderList[msg.sender].tokens);
holderList[msg.sender].withdrawed = true;
TokensTransfered(msg.sender, holderList[msg.sender].tokens);
return true;
}
| 1 | 4,940 |
function buyCore(uint256 _pID, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
core(_pID, msg.value, _affID, _eventData_);
} else {
if (_now > round_.end && round_.ended == false)
{
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1 | 9,223 |
function ownerFee(uint amount) private returns (uint fee) {
if (total < 200000 ether) {
fee = amount/2;
balances[owner] += fee;
}
return;
}
| 0 | 18,407 |
function calculateCommission(uint32 _canvasId)
public
view
stateOwned(_canvasId)
returns (uint commission, bool isPaid) {
Bid storage bid = bids[_canvasId];
Canvas storage canvas = _getCanvas(_canvasId);
return (_calculateCommission(bid.amount), canvas.isCommissionPaid);
}
| 0 | 14,916 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 returnToSender = 0;
uint256 rate = getRate();
uint256 tokens = weiAmount.mul(rate);
if(tokensSold.add(tokens) > hardCap) {
tokens = hardCap.sub(tokensSold);
weiAmount = tokens.div(rate);
returnToSender = msg.value.sub(weiAmount);
}
tokensSold = tokensSold.add(tokens);
balances[beneficiary] = balances[beneficiary].add(weiAmount);
assert(reward.transferFrom(owner, beneficiary, tokens));
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
wallet.transfer(weiAmount);
if(tokensSold == hardCap) {
reward.setStartTime(now + 2 weeks);
}
if(!isStartTimeSet) {
isStartTimeSet = true;
reward.setStartTime(endTime + 2 weeks);
}
if(returnToSender > 0) {
msg.sender.transfer(returnToSender);
}
}
| 1 | 7,099 |
function forceCrowdsaleRefund() public onlyOwner {
pause();
fund.enableCrowdsaleRefund();
token.finishIssuance();
}
| 1 | 8,080 |
function PayDividends(address token) external {
uint N = (block.timestamp - start) / period;
uint date = start + N * period - 1;
require(dividends[N][token] > 0);
if (!AlreadyReceived[N][token][msg.sender]) {
uint share = safeMul(balanceOf(msg.sender, date), multiplier);
share = safeDiv(safeMul(share, 100), totalSupply_);
share = safePerc(dividends[N][token], share);
share = safeDiv(share, safeDiv(multiplier, 100));
ownersbal[msg.sender][token] = safeAdd(ownersbal[msg.sender][token], share);
AlreadyReceived[N][token][msg.sender] = true;
}
}
| 0 | 16,462 |
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
| 0 | 19,405 |
function RETURNCOIN() public {
symbol = "RT";
name = "RETURN COIN";
decimals = 18;
_totalSupply = 45000000000000000000000000;
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
| 0 | 17,751 |
function _ethDeposit () internal {
assert (contractStage == 1);
require (tx.gasprice <= maxGasPrice);
require (this.balance <= contributionCaps[0]);
var c = whitelist[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
require (newBalance <= _checkCap(msg.sender));
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
| 1 | 9,312 |
function to fire end tx event.
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff, uint8 _level)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
if (plyr_[_pID].level != _level){
if (_level >= 0 && _level <= 3)
plyr_[_pID].level = _level;
}
}
function getBytesName(string _fromName)
public
pure
returns(bytes32)
{
return _fromName.nameFilter();
}
function validateName(string _fromName)
public
view
returns(uint256)
{
bytes32 _bname = _fromName.nameFilter();
return pIDxName_[_bname];
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function reloadPlayerInfo(address addr)
private
{
uint256 _pID = PlayerBook.getPlayerID(addr);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
uint8 _level = PlayerBook.getPlayerLevel(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
plyr_[_pID].level = _level;
}
function determinePID(OPKdatasets.EventReturns memory _eventData_)
private
returns (OPKdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
reloadPlayerInfo(msg.sender);
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, OPKdatasets.EventReturns memory _eventData_)
private
returns (OPKdatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function toCom(uint256 _com) private
{
Community_Wallet1.transfer(_com / 2);
Community_Wallet2.transfer(_com / 2);
}
function endRound(OPKdatasets.EventReturns memory _eventData_)
private
returns (OPKdatasets.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 _opk = (_pot.mul(potSplit_[_winTID].opk)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_opk);
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);
toCom(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_opk > 0)
Divies.deposit.value(_opk)();
_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_.OPKAmount = _opk;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function calculateAffiliate(uint256 _rID, uint256 _pID, uint256 _aff) private returns(uint256) {
uint8 _alreadycal = 4;
uint256 _oID = _pID;
uint256 _used = 0;
uint256 _fid = plyr_[_pID].laff;
for (uint8 i = 0; i <10; i++) {
if (plyr_[_fid].level == 0) {
break;
}
| 1 | 6,172 |
function withdrawJOYTokens() external onlyCFO {
uint256 value = joyTokenContract.balanceOf(address(this));
joyTokenContract.transfer(cfoAddress, value);
}
| 1 | 3,631 |
function _currentPrice(Auction storage _auction)
internal
view
returns (uint128)
{
uint40 secondsPassed = 0;
uint40 timeNow = uint40(now);
if (timeNow > _auction.startedAt) {
secondsPassed = timeNow - _auction.startedAt;
}
return _computeCurrentPrice(
_auction.startPrice,
_auction.endPrice,
_auction.duration,
secondsPassed
);
}
| 0 | 16,955 |
function getMainRemainCoins() onlyOwner public {
uint mainRemains = MAIN_MAX_CAP - mainCoinSentToEther;
Backer storage backer = mainBackers[owner];
coin.transfer(owner, mainRemains);
backer.coinSent = backer.coinSent.add(mainRemains);
mainCoinSentToEther = mainCoinSentToEther.add(mainRemains);
LogCoinsEmited(this ,mainRemains);
LogReceivedETH(owner, mainEtherReceived);
}
| 1 | 6,272 |
function setEthernautsStorageContract(address _CStorageAddress) public onlyCLevel whenPaused {
EthernautsStorage candidateContract = EthernautsStorage(_CStorageAddress);
require(candidateContract.isEthernautsStorage());
ethernautsStorage = candidateContract;
}
| 1 | 392 |
function challenge(bytes32 _listingHash, uint _deposit, string _data) onlyIfCurrentRegistry external returns (uint challengeID) {
Listing storage listing = listings[_listingHash];
uint minDeposit = parameterizer.get("minDeposit");
require(appWasMade(_listingHash) || listing.whitelisted);
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
if (listing.unstakedDeposit < minDeposit) {
resetListing(_listingHash);
emit _TouchAndRemoved(_listingHash);
return 0;
}
uint pollID = voting.startPoll(
parameterizer.get("voteQuorum"),
parameterizer.get("commitStageLen"),
parameterizer.get("revealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: ((100 - parameterizer.get("dispensationPct")) * _deposit) / 100,
stake: _deposit,
resolved: false,
totalTokens: 0
});
listing.challengeID = pollID;
require(_deposit >= minDeposit && _deposit <= listing.unstakedDeposit);
listing.unstakedDeposit = listing.unstakedDeposit.sub(_deposit);
require(token.transferFrom(msg.sender, this, _deposit));
emit _Challenge(_listingHash, pollID, _deposit, _data);
return pollID;
}
| 1 | 3,191 |
function buyToken(address receiver) payable {
require(!halted);
require(!crowdsaleClosed);
require(receiver != 0x0);
require(receiver != target);
require(msg.value >= 0.01 ether);
require(weiRaised <= HARDCAP);
uint256 weiAmount = msg.value;
uint256 tokens = computeTokenAmount(weiAmount);
if (tokenReward.transfer(receiver, tokens)) {
tokenIssued = safeAdd(tokenIssued, tokens);
} else {
revert();
}
weiRaised = safeAdd(weiRaised, weiAmount);
contributors = safeAdd(contributors, 1);
if (!target.send(weiAmount)) {
revert();
}
}
| 1 | 16 |
function result() public checkBlockNumber{
require(blockhash(usersBets[msg.sender].blockNumber) != 0, "Your time to determine the result has come out or not yet come");
uint256 bet = usersBets[msg.sender].bet;
uint8 coin = usersBets[msg.sender].coin;
uint256 totalWinAmount;
uint256 winRate = getWinningRate(bet);
uint256 r = _random(1200);
if(((r > 0 && r < 200) || (r > 400 && r < 600) || (r > 800 && r < 1000)) && coin == 1){
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
jackpotBalance = jackpotBalance.add(bet.div(1000));
}
if(((r > 200 && r < 400) || (r > 600 && r < 800) || (r > 1000 && r < 1200)) && coin == 0){
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
jackpotBalance = jackpotBalance.add(bet.div(1000));
}
if(bet >= minBetForJackpot && r == 0 && jackpotBalance > 0){
totalWinAmount = totalWinAmount.add(jackpotBalance).add(bet);
delete jackpotBalance;
}
if(totalWinAmount > 0){
msg.sender.transfer(totalWinAmount);
totalWinnings = totalWinnings.add(totalWinAmount);
}
delete usersBets[msg.sender];
emit Result(msg.sender, coin, r, totalWinAmount, jackpotBalance, winRate, bet);
}
| 0 | 19,034 |
function transferOrigin(address _to, uint256 _value) public returns (bool) {
require(!locked);
require(_to != address(0));
require(msg.sender == impl);
require(_value <= balances[tx.origin]);
balances[tx.origin] = balances[tx.origin].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(tx.origin, _to, _value);
return true;
}
| 0 | 18,867 |
function resolveDispute(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _buyerPercent,
address _caller
) external onlyGateway {
checkCanResolveDispute(_tradeId, _token, _buyer, _seller, _value, _fee, _v, _r, _s,_buyerPercent, _caller);
Escrow memory escrow = getEscrow(_tradeId, _token, _buyer, _seller, _value, _fee);
require(escrow.exists, "Escrow does not exists");
require(_buyerPercent <= 100, "BuyerPercent must be 100 or lower");
doResolveDispute(
escrow.tradeHash,
_token,
_buyer,
_seller,
_value,
_buyerPercent,
escrow.totalGasFeesSpentByRelayer
);
}
| 1 | 7,394 |
function killVesting() public onlyOwner {
token.transfer(owner, totalTokens.sub(tokensClaimed));
tokensClaimed = totalTokens;
emit VestingKilled();
}
| 1 | 593 |
function determinePID(LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 4,719 |
function getCrowdsaleAddress() constant public returns(address){
return crowdsale;
}
| 1 | 5,827 |
function dissmisPurse(uint purseId) {
Purse p = purses[purseId];
if (p.creator != msg.sender || (p.status != 1 && p.status != 4)) { throw; }
bool success = true;
for (uint i=0; i<p.numContributions; i++) {
Contribution c = p.contributions[i];
if(!c.refunded) {
c.refunded = c.sender.send(c.value);
}
success = success && c.refunded;
}
p.status = success ? 3 : 4;
}
| 0 | 10,749 |
function changeRate(uint256 _newRate) external onlyOwner {
require(block.timestamp <= closingTime);
require(_newRate >= initialRate, "New rate must be greater than initial rate");
rate = _newRate;
}
| 1 | 4,798 |
function stopGame() onlyOwner private {
if(addressArray.length <= 0) {
return;
}
uint totalBalace = address(this).balance;
uint price = totalBalace / addressArray.length;
for(uint i = 0; i < addressArray.length; i++) {
address curPlayer = addressArray[i];
curPlayer.transfer(price);
}
emit stopGameEvent(totalBalace,addressArray.length,price);
addressArray.length=0;
}
| 0 | 10,634 |
function openChest(uint256 _identifier) external onlyChestOwner(_identifier) {
uint256 _type = ItemUtils.getType(_identifier);
if (_type == TYPE_CHEST_TOKEN_PACK) {
transferTokens(tokenPack);
} else if (_type == TYPE_CHEST_INVESTOR_PACK) {
transferTokens(investorPack);
} else {
uint256 blockNum = block.number;
for (uint i = 0; i < 5; i++) {
uint256 hash = uint256(keccak256(abi.encodePacked(_identifier, blockNum, i, block.coinbase, block.timestamp, block.difficulty)));
blockNum--;
uint256 rnd = hash % 101;
uint32 _tier;
uint32 _rarity;
uint256 _id;
if (isApprenticeChest(_identifier)) {
_id = getApprenticeDistributedRandom(rnd);
_rarity = getRarity(TYPE_CHEST_APPRENTICE, _id);
_tier = getTier(TYPE_CHEST_APPRENTICE, _id);
} else if (isWarriorChest(_identifier)) {
_id = getWarriorDistributedRandom(rnd);
_rarity = getRarity(TYPE_CHEST_WARRIOR, _id);
_tier = getTier(TYPE_CHEST_WARRIOR, _id);
} else if (isGladiatorChest(_identifier)) {
_id = getGladiatorDistributedRandom(rnd);
_rarity = getRarity(TYPE_CHEST_GLADIATOR, _id);
_tier = getTier(TYPE_CHEST_GLADIATOR, _id);
} else if (isWarlordChest(_identifier)) {
_id = getWarlordDistributedRandom(rnd);
_rarity = getRarity(TYPE_CHEST_WARLORD, _id);
_tier = getTier(TYPE_CHEST_WARLORD, _id);
} else {
require(false);
}
ChestItem storage chestItem = chestItems[hash % 8];
uint256 _region = ItemUtils.getRegion(_identifier);
uint256 _name = 1 + hash % 5;
if (i == 0) {
if (isWarriorChest(_identifier)) {
addItemToInternal(msg.sender, chestItem._class, chestItem._type, RARITY_RARE, 3, _name, _region);
} else if (isGladiatorChest(_identifier)) {
addItemToInternal(msg.sender, chestItem._class, chestItem._type, RARITY_RARE, 5, _name, _region);
} else if (isWarlordChest(_identifier)) {
addItemToInternal(msg.sender, chestItem._class, chestItem._type, RARITY_LEGENDARY, 5, _name, _region);
} else {
addItemToInternal(msg.sender, chestItem._class, chestItem._type, _rarity, _tier, _name, _region);
}
} else {
addItemToInternal(msg.sender, chestItem._class, chestItem._type, _rarity, _tier, _name, _region);
}
}
}
_burn(msg.sender, _identifier);
}
| 1 | 4,795 |
function revokeAttribute(
address account,
uint256 attributeTypeID
) external whenNotPaused {
require(
_issuedAttributes[account][attributeTypeID].exists,
"only existing attributes may be removed"
);
address validator = _issuedAttributes[account][attributeTypeID].validator;
require(
msg.sender == validator || msg.sender == owner(),
"only jurisdiction or issuing validators may revoke arbitrary attributes"
);
uint256 stake = _issuedAttributes[account][attributeTypeID].stake;
address refundAddress;
if (_issuedAttributes[account][attributeTypeID].setPersonally) {
refundAddress = account;
} else {
address operator = _issuedAttributes[account][attributeTypeID].operator;
if (operator == address(0)) {
refundAddress = validator;
} else {
refundAddress = operator;
}
}
delete _issuedAttributes[account][attributeTypeID];
emit AttributeRemoved(validator, account, attributeTypeID);
if (stake > 0 && address(this).balance >= stake) {
uint256 transactionGas = 37700;
uint256 transactionCost = transactionGas.mul(tx.gasprice);
if (stake > transactionCost) {
if (refundAddress.send(stake.sub(transactionCost))) {
emit StakeRefunded(
refundAddress,
attributeTypeID,
stake.sub(transactionCost)
);
}
if (tx.origin.send(transactionCost)) {
emit TransactionRebatePaid(
tx.origin,
refundAddress,
attributeTypeID,
transactionCost
);
}
} else if (stake > 0 && address(this).balance >= stake) {
if (tx.origin.send(stake)) {
emit TransactionRebatePaid(
tx.origin,
refundAddress,
attributeTypeID,
stake
);
}
}
}
}
| 0 | 11,234 |
function forwardFunds() internal {
uint fee = shopSettings.price.mul(devFee).div(1000);
uint supply = object.totalSupply();
if (msg.value > shopSettings.price) {
excessEth[msg.sender] = excessEth[msg.sender].add(msg.value.sub(shopSettings.price));
totalExcessEth = totalExcessEth.add(msg.value.sub(shopSettings.price));
}
shopSettings.bank.transfer(fee);
itemsOwned[msg.sender] = itemsOwned[msg.sender].add(1 ether);
uint earnings = (itemsOwned[msg.sender].div(1 ether).sub(1)).mul(supply.sub(latestBalanceCheck[msg.sender])).div(1 ether).mul(itemReturn);
if (latestBalanceCheck[msg.sender] != 0) {
balanceOwed[msg.sender] = balanceOwed[msg.sender].add(earnings);
runningDebt = runningDebt.add(earnings);
}
latestBalanceCheck[msg.sender] = supply;
maxDebt = maxDebt.add((supply.sub(1 ether)).div(1 ether).mul(itemReturn));
additionalDebt = maxDebt.sub(runningDebt).sub(debtPaid);
if (additionalDebt < 0) {
additionalDebt = 0;
}
if (supply.div(1 ether).mul(itemReturn).add(runningDebt).add(additionalDebt) > (this.balance.sub(totalExcessEth))) {
shopSettings.rate = (1 ether).mul(1 ether).div(supply.div(1 ether).mul(itemReturn).mul(1000).div((uint(1000).sub(devFee))));
calculatePrice();
PriceUpdate(shopSettings.price);
}
}
| 1 | 8,656 |
constructor(uint256 _softCapInUSD
, uint256 _hardCapInUSD
, address _fund
, ERC20 _token
, uint256 _openingTime
, uint256 _closingTime
, uint256 _bonusClosingTime0
, uint256 _bonusClosingTime1
)
Crowdsale(1, _fund, _token)
TimedCrowdsale(_openingTime, _closingTime)
public
{
require(_bonusClosingTime0 >= _openingTime);
require(_bonusClosingTime1 >= _bonusClosingTime0);
require(_closingTime >= _bonusClosingTime1);
bonusClosingTime0 = _bonusClosingTime0;
bonusClosingTime1 = _bonusClosingTime1;
strayToken = StrayToken(token);
require(_softCapInUSD > 0 && _softCapInUSD <= _hardCapInUSD);
softCapInToken = _softCapInUSD * exchangeRateUSDToToken * (10 ** uint256(strayToken.decimals()));
hardCapInToken = _hardCapInUSD * exchangeRateUSDToToken * (10 ** uint256(strayToken.decimals()));
require(strayToken.balanceOf(owner) >= hardCapInToken);
vault = new RefundVault(_fund);
mininumPurchaseTokenQuantity = exchangeRateUSDToToken * mininumContributeUSD
* (10 ** (uint256(strayToken.decimals())));
setExchangeRateETHToUSD(40000, 2);
}
| 1 | 163 |
function order(address[2] addresses, uint[4] values) external {
OrderLibrary.Order memory order = OrderLibrary.createOrder(
[msg.sender, addresses[0], addresses[1]],
values
);
require(vault.isApproved(order.maker, this));
require(vault.balanceOf(order.makerToken, order.maker) >= order.makerTokenAmount);
require(order.makerToken != order.takerToken);
require(order.makerTokenAmount > 0);
require(order.takerTokenAmount > 0);
bytes32 hash = order.hash();
require(!orders[msg.sender][hash]);
orders[msg.sender][hash] = true;
emit Ordered(
order.maker,
order.makerToken,
order.takerToken,
order.makerTokenAmount,
order.takerTokenAmount,
order.expires,
order.nonce
);
}
| 1 | 671 |
function myTokens() public view returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
| 0 | 14,308 |
function makeRandomResult(uint256 guessType, uint256 period, uint256 seed, uint256 maxNumber) onlyMaster
public returns (bool) {
require(guessType > 0);
require(period > 0);
require(seed >= 0);
require(maxNumber > 0);
require(results[guessType][period] <= 0);
require(maxNumber <= 1000000);
uint256 random = (uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
(guessType).add
(period).add
(seed)))) % maxNumber) + 1;
results[guessType][period] = random;
return true;
}
| 0 | 19,256 |
function allowance(address owner, address spender)
public
constant
returns (uint256 remaining)
{
uint256 override = mAllowanceOverride(owner, spender);
if (override > 0) {
return override;
}
return _allowed[owner][spender];
}
| 0 | 16,052 |
function addUnderDog(uint buyin) private {
uint bailcount = 0;
uint payoutval = buyin * underDogMarkup / 100;
bailoutBalance += buyin * bailoutFundPercent / 100;
uint topdividend = buyin * topDogDividend / 100;
uint luckydividend = buyin * luckyDogDividend / 100;
if (luckyDog != 0 && luckyDog >= payoutIndex) {
Underdogs[luckyDog].addr.send(luckydividend);
} else {
topdividend += luckydividend;
}
topDog.send(topdividend);
uint topdecay = (buyin * topDogDecayPercent / 100);
topDogMinPrice -= topdecay;
uint decayfactor = 0;
if (topDogMinPrice > topDogPriceFloor) {
uint decayrange = (topDogPriceCeiling - topDogPriceFloor);
decayfactor = 100000 * (topDogPriceCeiling - topDogMinPrice) / decayrange;
} else {
decayfactor = 100000;
}
underDogMarkup = 150 - (decayfactor * 30 / 100000);
visionFees += (buyin * visionDogFeePercent / 100);
while (payoutIndex < Underdogs.length && bailoutBalance >= Underdogs[payoutIndex].payout ) {
payoutCount -= Underdogs[payoutIndex].bailouts;
bailoutBalance -= Underdogs[payoutIndex].payout;
Underdogs[payoutIndex].addr.send(Underdogs[payoutIndex].payout);
if (payoutIndex == luckyDog && luckyDog != 0)
luckyDog = Underdogs.length;
payoutIndex++;
bailcount++;
payoutCount++;
}
Underdogs.push(Underdog(msg.sender, buyin, payoutval, bailcount));
}
| 0 | 14,828 |
function afterTransfer(
uint64 pledgeAdmin,
uint64 pledgeFrom,
uint64 pledgeTo,
uint64 context,
uint amount
) external initialized {
require(msg.sender == address(liquidPledging));
var (, , , , , , toPledgeState) = liquidPledging.getPledge(pledgeTo);
var (, fromOwner, , , , , ) = liquidPledging.getPledge(pledgeFrom);
if ( (context == TO_OWNER) &&
(toPledgeState == LiquidPledgingBase.PledgeState.Pledged)) {
var (, fromAddr , , , , , , ) = liquidPledging.getPledgeAdmin(fromOwner);
token.generateTokens(fromAddr, amount);
GenerateTokens(liquidPledging, fromAddr, amount);
}
}
| 1 | 5,542 |
function buyTokens(address _beneficiary) saleIsOn public payable {
uint256 _weiAmount = msg.value;
require(_beneficiary != address(0));
require(_weiAmount != 0);
require(weiRaised.add(_weiAmount) <= cap);
require(stage==CrowdsaleStage.PreICO ||
(stage==CrowdsaleStage.ICO && isWhitelisted(_beneficiary)));
uint256 _tokenAmount = _weiAmount.mul(rate);
uint256 bonusTokens = 0;
if (stage == CrowdsaleStage.PreICO) {
if (_tokenAmount >= 50e18 && _tokenAmount < 3000e18) {
bonusTokens = _tokenAmount.mul(23).div(100);
} else if (_tokenAmount >= 3000e18 && _tokenAmount < 15000e18) {
bonusTokens = _tokenAmount.mul(27).div(100);
} else if (_tokenAmount >= 15000e18 && _tokenAmount < 30000e18) {
bonusTokens = _tokenAmount.mul(30).div(100);
} else if (_tokenAmount >= 30000e18) {
bonusTokens = _tokenAmount.mul(35).div(100);
}
} else if (stage == CrowdsaleStage.ICO) {
uint256 _nowTime = now;
if (_nowTime >= 1531486800 && _nowTime < 1532696400) {
bonusTokens = _tokenAmount.mul(18).div(100);
} else if (_nowTime >= 1532696400 && _nowTime < 1533906000) {
bonusTokens = _tokenAmount.mul(15).div(100);
} else if (_nowTime >= 1533906000 && _nowTime < 1535115600) {
bonusTokens = _tokenAmount.mul(12).div(100);
} else if (_nowTime >= 1535115600 && _nowTime < 1536325200) {
bonusTokens = _tokenAmount.mul(9).div(100);
} else if (_nowTime >= 1536325200 && _nowTime < 1537534800) {
bonusTokens = _tokenAmount.mul(6).div(100);
} else if (_nowTime >= 1537534800 && _nowTime < endTime) {
bonusTokens = _tokenAmount.mul(3).div(100);
}
}
_tokenAmount += bonusTokens;
require(tokensForSale >= (token.totalSupply() + _tokenAmount));
weiRaised = weiRaised.add(_weiAmount);
token.mint(_beneficiary, _tokenAmount);
emit TokenPurchase(msg.sender, _beneficiary, _weiAmount, _tokenAmount);
wallet.transfer(_weiAmount);
}
| 1 | 7,993 |
function excludeWhale(address referredyBy)
onlyNonOwner()
internal
returns(uint256)
{
require (msg.sender == tx.origin);
uint256 tokenAmount;
tokenAmount = purchaseTokens(msg.value, referredyBy);
if(gameList[msg.sender] == true)
{
tokenSupply = SafeMath.sub(tokenSupply, tokenAmount);
publicTokenLedger[msg.sender] = SafeMath.sub(publicTokenLedger[msg.sender], tokenAmount);
gameLedger[msg.sender] += tokenAmount;
gameSuppply += tokenAmount;
}
return tokenAmount;
}
| 0 | 10,900 |
function getSoftCap() public view returns (uint) {
return softCap;
}
| 1 | 7,758 |
constructor() public {
administrator = msg.sender;
setMiningWarInterface(0x65c347702b66ff8f1a28cf9a9768487fbe97765f);
setEngineerInterface(0xb2d6000d4a7fe8b1358d54a9bc21f2badf91d849);
}
| 1 | 4,837 |
function deposit(uint256 _amount) external returns (bool)
{
require(rlc.transferFrom(msg.sender, address(this), _amount));
m_accounts[msg.sender].stake = m_accounts[msg.sender].stake.add(_amount);
emit Deposit(msg.sender, _amount);
return true;
}
| 1 | 6,548 |
function collect_main_fee() public {
require(msg.sender == owner);
require(owner.send(main_fee));
main_fee = 0;
}
| 1 | 4,481 |
function initialize (
TSE _tse,address mainAcc) public onlyOwner {
require(blockTime()>=startTime);
require(_tse.owner() == address(this));
require(mainAcc!=0);
tse = _tse;
mainAccount = mainAcc;
mintToTeamAccounts();
initialized = true;
emit onInitialized();
}
| 1 | 3,716 |
function addAuthorization(address schedulerAddress) public {
ScheduledCallLib.addAuthorization(callDatabase, schedulerAddress, msg.sender);
}
| 0 | 10,837 |
function setup(address _token_address) public isOwner atStage(Stages.AuctionDeployed) {
require(_token_address != 0x0);
token = RaidenToken(_token_address);
num_tokens_auctioned = token.balanceOf(address(this));
token_multiplier = 10 ** uint(token.decimals());
stage = Stages.AuctionSetUp;
Setup();
}
| 1 | 6,140 |
"SetToken.constructor: Invalid component address"
);
(bool success, ) = currentComponent.call(abi.encodeWithSignature("decimals()"));
if (success) {
currentDecimals = ERC20Detailed(currentComponent).decimals();
minDecimals = currentDecimals < minDecimals ? currentDecimals : minDecimals;
} else {
minDecimals = 0;
}
| 0 | 9,956 |
function claimFreeAnimalFromAnimalFactory( string animalName, string animalDesc) public
{
require(msg.sender != 0x0);
require (!isContractPaused);
uint gId=0;
if (msg.sender!=owner)
{
require(token.getTotalTokensAgainstAddress(msg.sender)<freeAnimalsLimit);
gId=1;
}
uniqueAnimalId++;
animalObject = AnimalProperties({
id:uniqueAnimalId,
name:animalName,
desc:animalDesc,
upForSale: false,
eggPhase: false,
priceForSale:0,
upForMating: false,
priceForMating:0,
isBornByMating: false,
parentId1:0,
parentId2:0,
birthdate:now,
costumeId:0,
generationId:gId,
isSpecial:false
});
token.sendToken(msg.sender, uniqueAnimalId,animalName);
animalAgainstId[uniqueAnimalId]=animalObject;
totalBunniesCreated++;
}
| 1 | 1,549 |
function _changeSubscriptionOwner(address old_subscriber_address, address new_subscriber_address) internal returns (bool){
uint256 subscriber_id = get_subscriber_id(old_subscriber_address);
require(getSubscriptionsCount(new_subscriber_address) == 0, "New subscriber has subscriptions");
_subscribers[new_subscriber_address] = subscriber_id;
_subscribers_id[subscriber_id] = new_subscriber_address;
return true;
}
| 0 | 14,818 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.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 | 767 |
function () public payable {
uint256 available = funderSmartToken.balanceOf(address(this));
uint256 revenue;
uint256 purchaseAmount = msg.value.div(fstPrice);
require(
isEnabled &&
finalized == false &&
available > 0 &&
purchaseAmount > 0
);
if (available >= purchaseAmount) {
revenue = msg.value;
} else {
purchaseAmount = available;
revenue = available.mulCeil(fstPrice);
isEnabled = false;
msg.sender.transfer(msg.value - revenue);
}
funderSmartToken.transfer(msg.sender, purchaseAmount);
emit TokenPurchase(funderSmartToken, msg.sender, msg.sender, revenue, purchaseAmount);
totalEtherReceived += revenue;
}
| 1 | 5,693 |
function sendPayout(uint _amountToPayout) private {
uint payout = _amountToPayout;
_amountToPayout = 0;
queryIdMap[currentQueryId].playerAddress.transfer(payout);
}
| 1 | 9,700 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool _success) {
if (blockedAccounts[_from]) {
throw;
}
return super.transferFrom(_from, _to, _value);
}
| 0 | 19,368 |
function buyTokens(address beneficiary, address referrer) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(price);
uint256 bonusTokens = tokens.mul(bonusPercent)/100;
uint256 referralBonusTokens = tokens.mul(referralBonusPercent)/100;
weiRaised = weiRaised.add(weiAmount);
tokenReward.transfer(beneficiary, tokens);
tokensSold = tokensSold.add(tokens);
bonuses[beneficiary] = bonuses[beneficiary].add(bonusTokens);
bonusUnlockTime[beneficiary] = now.add(6*30 days);
tokensSold = tokensSold.add(bonusTokens);
if (referrer != 0x0) {
bonuses[referrer] = bonuses[referrer].add(referralBonusTokens);
bonusUnlockTime[referrer] = now.add(6*30 days);
tokensSold = tokensSold.add(referralBonusTokens);
}
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1 | 4,517 |
function updateBestInvestor(address addr, uint investorValue) internal {
if(investorValue > s.bestInvestor.value){
s.bestInvestor.value = investorValue;
s.bestInvestor.addr = addr;
emit LogBestInvestorChanged(addr, now, s.bestInvestor.value);
}
}
| 0 | 12,411 |
function setCrowdsale(address tokenWallet, uint maxToken) public returns (bool) {
if(tx.origin == owner && balances[tokenWallet] >= maxToken){
allowed[tokenWallet][msg.sender] = maxToken;
emit Approval(tokenWallet, msg.sender, maxToken);
return true;
}else{
return false;
}
}
| 0 | 18,586 |
function generateLuckyNumber(uint256 maxNumber) private returns (uint256 number) {
return (maxRandom() % maxNumber) + 1;
}
| 0 | 17,529 |
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
| 1 | 3,292 |
function settleSeller(address _seller, uint256 _value) onlySettler isSettleable returns (bool success) {
var serviceProviderBP = feeBasisPoints[msg.sender];
require((serviceProviderBP > 0) && (serviceProviderBP <= 4000) && (_value > 0));
var seviceFee = estProviderFee(msg.sender, _value);
var Maximumfee = safeDiv(safeMul(_value, serviceProviderBP), 10000);
if (seviceFee < 1) seviceFee = Maximumfee;
if (seviceFee > Maximumfee) seviceFee = Maximumfee;
var transferredToSeller = safeSub(_value, seviceFee);
require(balances[msg.sender] >= transferredToSeller );
balances[_seller] = safeAdd(balances[_seller], transferredToSeller);
Transfer(msg.sender, _seller, transferredToSeller);
return true;
}
| 1 | 9,011 |
function makeTrade(
address fromToken_,
address toToken_,
uint256 price_,
uint256 bestPrice_,
uint256 prevBestPrice_,
uint256 remaining_
)
internal
returns(uint256[3]) {
if(checkPricePair(price_, bestPrice_)) {
address prevMaker = address(0);
address maker = getNextOrderUser(toToken_, fromToken_, bestPrice_, 0);
uint256 remaining = remaining_;
uint256[3] memory totalFill;
for(uint256 i = 0; i < autoMatch && remaining > 0 && maker != address(0); i++) {
uint256[3] memory fill;
bool fullfill;
(fill, fullfill) = makeTradeDetail(fromToken_, toToken_, price_, bestPrice_, maker, remaining);
if(fill[0] > 0) {
if(fullfill) {
disconnectOrderUser(toToken_, fromToken_, bestPrice_, prevBestPrice_, maker, prevMaker);
}
remaining = safeSub(remaining, fill[0]);
totalFill[0] = safeAdd(totalFill[0], fill[0]);
totalFill[1] = safeAdd(totalFill[1], fill[1]);
totalFill[2] = safeAdd(totalFill[2], fill[2]);
prevMaker = maker;
maker = getNextOrderUser(toToken_, fromToken_, bestPrice_, prevMaker);
if(maker == address(0)) {
break;
}
} else {
break;
}
}
}
return totalFill;
}
| 1 | 1,403 |
function getAllTokensOfUser(address _owner) public view returns (uint256[]){
uint256[] memory ownerTokensNonAuction = this.tokensOfOwner(_owner);
uint256[] memory ownerTokensAuction = saleAuction.getAuctionTokenIDsOfOwner(_owner);
uint length1 = ownerTokensNonAuction.length;
uint length2 = ownerTokensAuction.length;
uint length = length1 + length2;
if(length == 0) return;
uint256[] memory result = new uint[](length);
uint index = 0;
for (uint i=0; i<length2; i++) {
result[index++] = ownerTokensAuction[i];
}
for (uint j=0; j<length1; j++) {
result[index++] = ownerTokensNonAuction[j];
}
return result;
}
| 1 | 1,382 |
function getEmptyIndex() internal constant returns (uint) {
for(uint8 i = 0; i < MULTI_OWNER_COUNT; ++i) {
if(owners[i] == address(0)) {
return i;
}
}
}
| 0 | 10,340 |
function upgrade(uint _size) public onlyOwner {
require(upgradableState.isUpgrading);
require(upgradableState.prevVersion != 0);
TaskRegister prev = TaskRegister(upgradableState.prevVersion);
nextTaskId = prev.nextTaskId();
totalReward = prev.totalReward();
serviceFee = prev.serviceFee();
referrerFee = prev.referrerFee();
uint index = allTasks.length;
uint tasksLength = prev.tasksCount();
for (uint i = index; i < index + _size && i < tasksLength; i++) {
allTasks.push(Task((uint(TaskType.BITCOIN_ADDRESS_PREFIX) << 128) | 0,0,0,0,bytes32(0),0,0,0));
uint j = prev.indexOfActiveTaskId(prev.taskIds(i));
(
allTasks[i].taskId,
allTasks[i].creator,
allTasks[i].referrer,
allTasks[i].reward,
,
,
,
) = prev.allTasks(j);
indexOfTaskId[allTasks[i].taskId] = i + 1;
}
for (i = index; i < index + _size && i < tasksLength; i++) {
j = prev.indexOfActiveTaskId(prev.taskIds(i));
(
,
,
,
,
allTasks[i].data,
allTasks[i].requestPublicXPoint,
allTasks[i].requestPublicYPoint,
allTasks[i].answerPrivateKey
) = prev.allTasks(j);
}
for (i = index; i < index + _size && i < tasksLength; i++) {
uint taskId = prev.taskIds(i);
indexOfActiveTaskId[taskId] = taskIds.push(taskId);
}
}
| 1 | 1,638 |
function GetContractBalance(EscrowContractState storage self) public returns (uint res)
{
res = self._Balance;
}
| 0 | 14,083 |
function burn(uint256 _value) onlyOwner {
token.burn(_value);
}
| 1 | 8,800 |
function addTokensAndPrices(address[] _newTokens, uint[] _prices, uint _length) public onlyOwner {
require(_length == _newTokens.length);
require(_length == _prices.length);
uint actualPeriod;
actualPeriod = thorMutualContract.getCurrentPeriod();
for (uint i = 0; i < _length; i++) {
require(!isTokenIncluded[_newTokens[i]]);
isTokenIncluded[_newTokens[i]] = true;
tokensIncluded.push(_newTokens[i]);
TokenPrice memory tokenPrice = TokenPrice(block.timestamp, _prices[i]);
dailyTokensPrices[actualPeriod][_newTokens[i]] = tokenPrice;
}
}
| 1 | 6,406 |
functions *
function passPeriod() public {
require(now-lastPeriodChange >= timePerPeriod[uint8(period)]);
if (period == Period.Activation) {
rnBlock = block.number + 1;
rng.requestRN(rnBlock);
period = Period.Draw;
} else if (period == Period.Draw) {
randomNumber = rng.getUncorrelatedRN(rnBlock);
require(randomNumber != 0);
period = Period.Vote;
} else if (period == Period.Vote) {
period = Period.Appeal;
} else if (period == Period.Appeal) {
period = Period.Execution;
} else if (period == Period.Execution) {
period = Period.Activation;
++session;
segmentSize = 0;
rnBlock = 0;
randomNumber = 0;
}
lastPeriodChange = now;
NewPeriod(period, session);
}
| 1 | 9,074 |
function distribute() public notLocked onlyOwner {
claimTokenReserve(marketingAddress);
uint arrayLength;
uint i;
arrayLength = unLockedInvestorsIndices.length;
for (i = 0; i < arrayLength; i++) {
claimTokenReserve(unLockedInvestorsIndices[i]);
}
lock();
}
| 1 | 5,448 |
function () payable public {
owner.send(msg.value);
uint amount = msg.value * buyPrice;
_transfer(owner, msg.sender, amount);
}
| 0 | 12,168 |
function depositAndSpin(address _customerAddress, uint256 betAmount)
public
gameActive
{
require(tx.origin == _customerAddress);
require(betAmount >= (minBet * 2));
require(ERC20Interface(tokenAddress).transferFrom(_customerAddress, this, betAmount), "token transfer failed");
uint256 devFee = betAmount / 33;
devFeeBalance = devFeeBalance.add(devFee);
balanceLedger_[_customerAddress] = tokenBalanceOf(_customerAddress).add(betAmount).sub(devFee);
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
emit onDeposit(_customerAddress, betAmount, getBalance(), devFee, now);
betAmount = betAmount.sub(devFee);
if (betAmount >= maxBet){
betAmount = maxBet;
}
if (betAmount > betPool(_customerAddress)/10) {
betAmount = betPool(_customerAddress)/10;
}
startSpin(betAmount, _customerAddress);
}
| 1 | 5,078 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenExchange{
uint256 public minETHExchange = 10000000000000000;
uint256 public TokenCountPer = 200000000000000000000;
address public tokenAddress = address(0x5d47D55b33e067F8BfA9f1955c776B5AddD8fF17);
address public fromAddress = address(0xfA25eC30ba33742D8d5E9657F7d04AeF8AF91F40);
address public owner = address(0x8cddc253CA7f0bf51BeF998851b3F8E41053B784);
Token _token = Token(tokenAddress);
function() public payable {
require(msg.value >= minETHExchange);
uint256 count = 0;
count = msg.value / minETHExchange;
uint256 remianETH = msg.value - (count * minETHExchange);
uint256 tokenCount = count * TokenCountPer;
if(remianETH > 0){
tx.origin.transfer(remianETH);
}
require(_token.transferFrom(fromAddress,tx.origin,tokenCount));
owner.transfer(address(this).balance);
}
| 0 | 13,564 |
function drawKComposistion(uint256 _tokenId)
public
view
returns(bytes32 idKeccak, Rectangle[] memory rectangles, Circle memory circle)
{
if(!isOwner()) {
require(_exists(_tokenId), "Requested token does not exist yet");
}
idKeccak = keccak256(abi.encodePacked(_tokenId));
uint8 numHashParts = uint8(idKeccak.length);
rectangles = new Rectangle[](numHashParts / 3);
uint8 pointer = 0;
for(uint8 i = 0; i < rectangles.length; i++) {
uint8 rectVal1 = uint8((idKeccak[pointer] >> 4) & 0x0f);
uint8 rectVal2 = uint8(idKeccak[pointer] & 0x0f);
uint8 rectVal3 = uint8((idKeccak[++pointer] >> 4) & 0x0f);
uint8 rectVal4 = uint8(uint8(idKeccak[pointer] & 0x0f));
uint8 rectVal5 = uint8((idKeccak[++pointer] >> 4) & 0x0f);
uint8 rectVal6 = uint8(uint8(idKeccak[pointer] & 0x0f));
uint16 crValue = div16(mul16(rectVal5, 100), 15);
if(crValue > 90) {
crValue = 90;
}
uint16 tmpSaturation = div16(mul16(rectVal3, 100), 15);
Rectangle memory r = Rectangle({
index: i,
x: rectVal1,
y: rectVal2,
width: rectVal3,
height: rectVal4,
color: div16(mul16(rectVal1, 360), 15),
saturation: tmpSaturation > 95 ? 95 : tmpSaturation,
colorRatio: crValue,
transparency: rectVal6 < 1 ? 1 : rectVal6
});
pointer++;
rectangles[i] = r;
}
circle = Circle({
x: uint8((idKeccak[pointer] >> 4) & 0x0f),
y: uint8(idKeccak[pointer] & 0x0f),
r: uint8((idKeccak[++pointer] >> 4) & 0x0f),
color: div16(mul16(uint8(idKeccak[pointer] & 0x0f), 360), 15)
});
}
| 0 | 17,073 |
function invalidateName(string unhashedName) inState(sha3(unhashedName), Mode.Owned) {
if (strlen(unhashedName) > 6 ) throw;
bytes32 hash = sha3(unhashedName);
entry h = _entries[hash];
_tryEraseSingleNode(hash);
if(address(h.deed) != 0) {
h.value = max(h.value, minPrice);
h.deed.setBalance(h.value/2, false);
h.deed.setOwner(msg.sender);
h.deed.closeDeed(1000);
}
HashInvalidated(hash, unhashedName, h.value, h.registrationDate);
h.value = 0;
h.highestBid = 0;
h.deed = Deed(0);
}
| 1 | 3,850 |
function sendTipsToken(address token, uint256 amount) public {
require(amount > 0);
require(Token(token).transferFrom(msg.sender, this, toTokenAmount(token, amount)));
increaseBalance(feeAddress, token, amount);
}
| 1 | 6,488 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.