func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = RatBook.getPlayerID(msg.sender);
bytes32 _name = RatBook.getPlayerName(_pID);
uint256 _laff = RatBook.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 | 6,228 |
function reinvest(uint256 weiAmount) public {
ethStorage[msg.sender] = ethStorage[msg.sender].sub(weiAmount);
uint256 tokensAmount;
(weiAmount, tokensAmount) = mint(msg.sender, weiAmount);
if (weiAmount > 0) {
ethStorage[msg.sender] = ethStorage[msg.sender].add(weiAmount);
}
emit Reinvest(msg.sender, weiAmount, tokensAmount, now);
}
| 1 | 4,447 |
function ERC20MintableToken(Minter _minter) public {
owner = tx.origin;
minter = _minter;
}
| 0 | 14,034 |
function safeWithdrawal() afterDeadline public {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
| 0 | 10,146 |
function buy(address buyer) whenNotPaused whenNotFinished public payable {
require(buyer != address(0));
require(msg.value != 0);
require(msg.value >= minimalPrice);
uint256 amount = msg.value;
uint256 tokens = amount.mul(tokenPrice).mul(discount.add(100)).div(100);
balanceOf[buyer] = balanceOf[buyer].add(amount);
tokenReward.mint(buyer, tokens);
amountRaised = amountRaised.add(amount);
}
| 1 | 5,787 |
function closeAuction() public {
assert(isActive);
assert(auctionCloseBlock < block.number);
assert(msg.sender == winner);
msg.sender.transfer(prize);
Auctioneer auctioneer = Auctioneer(auctioneerAddress);
if(firstBidder != address(0)) {
uint firstValue = bettingMap[firstBidder];
if (firstValue >= minimalPrize) {
address firstContract = auctioneer.createAuctionContract.value(firstValue)();
firstBetContract = firstContract;
}
}
if(secondBidder != address(0)) {
uint secondValue = bettingMap[secondBidder];
if (secondValue >= minimalPrize) {
address secondContract = auctioneer.createAuctionContract.value(secondValue)();
secondBetContract = secondContract;
}
}
isActive = false;
}
| 1 | 9,504 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(block.blockhash(block.number)) + block.timestamp + block.difficulty + block.number;
if (mulmod(random, 1, 2) == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
}
| 0 | 15,018 |
function getProfit(uint8 _probability, uint256 _betValue) view internal returns (uint256){
uint256 tempProfit = ((_betValue * (100 - _probability) / _probability + _betValue) * (1000 - houseEdge) / 1000) - _betValue;
if(tempProfit > maxProfit) tempProfit = maxProfit;
return tempProfit;
}
| 0 | 10,519 |
function begin() public
{
require(rightAndRoles.onlyRoles(msg.sender,22));
if (isBegin) return;
isBegin=true;
financialStrategy = creator.createFinancialStrategy();
token.setUnpausedWallet(rightAndRoles.wallets(1,0), true);
token.setUnpausedWallet(rightAndRoles.wallets(3,0), true);
token.setUnpausedWallet(rightAndRoles.wallets(4,0), true);
token.setUnpausedWallet(rightAndRoles.wallets(5,0), true);
token.setUnpausedWallet(rightAndRoles.wallets(6,0), true);
bonuses.push(Bonus(1429 finney, 2,0));
bonuses.push(Bonus(14286 finney, 5,0));
bonuses.push(Bonus(142857 finney, 10,0));
profits.push(Profit(20,5 days + 36000));
profits.push(Profit(15,5 days));
profits.push(Profit(10,5 days));
profits.push(Profit(5,5 days));
}
| 1 | 8,835 |
function confirmOrder(bytes32 _orderID, bytes32 _matchedOrderID) external onlyDarknode(msg.sender) {
require(orders[_orderID].state == OrderState.Open, "invalid order status");
require(orders[_matchedOrderID].state == OrderState.Open, "invalid order status");
orders[_orderID].state = OrderState.Confirmed;
orders[_orderID].confirmer = msg.sender;
orders[_orderID].matchedOrder = _matchedOrderID;
orders[_orderID].blockNumber = block.number;
orders[_matchedOrderID].state = OrderState.Confirmed;
orders[_matchedOrderID].confirmer = msg.sender;
orders[_matchedOrderID].matchedOrder = _orderID;
orders[_matchedOrderID].blockNumber = block.number;
}
| 1 | 1,479 |
function addContract(address addr) public returns(bool success) {
contracts[addr] = addr;
return true;
}
| 0 | 10,262 |
function refill(address _to, uint256 _amount, string _paySystem) onlyModer public returns (bool success) {
uint256 fee;
uint256 resultAmount;
fee = comissionList.calcRefill(_paySystem, _amount);
resultAmount = _amount.sub(fee);
balances[_to] = balances[_to].add(resultAmount);
balances[staker] = balances[staker].add(fee);
totalSupply_ = totalSupply_.add(_amount);
emit Transfer(address(0), _to, resultAmount);
emit Transfer(address(0), address(0), fee);
return true;
}
| 1 | 2,150 |
function startCollection() isState(EventState.Waiting) {
require(now > startTime);
var contr = Controller(controllerAddr);
powerAddr = contr.powerAddr();
nutzAddr = contr.nutzAddr();
initialSupply = contr.activeSupply().add(contr.powerPool()).add(contr.burnPool());
initialReserve = nutzAddr.balance;
uint256 ceiling = contr.ceiling();
uint256 newCeiling = ceiling.mul(discountRate).div(RATE_FACTOR);
contr.moveCeiling(newCeiling);
state = EventState.Collecting;
}
| 1 | 6,527 |
function () public payable {
require(!saleClosed);
require(msg.value >= 1 finney);
uint256 amount = msg.value * 80000;
require(amount <= pearl.balanceOf(this));
pearl.transfer(msg.sender, amount);
funds += msg.value;
director.transfer(this.balance);
}
| 1 | 1,498 |
function buyTicket(uint poolIndex, uint ticketCount, address websiteFeeAddr) public payable
{
require(poolIndex < pools.length);
require(ticketCount > 0);
SmartPool pool = pools[poolIndex];
pool.checkEnd();
require (!pool.isEnded());
uint availableCount = pool.getAvailableTicketCount();
if (ticketCount > availableCount)
ticketCount = availableCount;
uint amountRequired = ticketCount * pool.getTicketPrice();
require(msg.value >= amountRequired);
uint amountLeft = msg.value - amountRequired;
if (websiteFeeAddr == address(0))
websiteFeeAddr = wallet;
uint feeAmount = amountRequired / feeDivider;
addFee(websiteFeeAddr, feeAmount);
addFee(wallet, feeAmount);
pool.addPlayer(msg.sender, ticketCount, amountRequired - 2 * feeAmount);
if (amountLeft > 0 && !msg.sender.send(amountLeft))
{
addFee(wallet, amountLeft);
}
updateSeed();
}
| 1 | 5,381 |
function manualSend ( address tokenholder, uint packagenumber ) onlyOwner {
if ( packagenumber != 1 && packagenumber != 2 && packagenumber != 3 ) revert();
uint award;
uint donation;
if ( packagenumber == 1 ) { award = 10800000000; donation = 800000000; }
if ( packagenumber == 2 ) { award = 108800000000; donation = 8800000000; }
if ( packagenumber == 3 ) { award = 1088800000000; donation = 88800000000; }
tokenReward.transfer ( tokenholder , award );
tokenReward.transfer ( charity , donation );
presold = presold.add( award );
presold = presold.add( donation );
tokensSold = tokensSold.add(award);
tokensSold = tokensSold.add(donation);
}
| 1 | 3,798 |
constructor(
address _exchange,
address selectorProvider,
address totlePrimary,
address _weth,
address errorReporter
)
ExchangeHandler(selectorProvider, totlePrimary, errorReporter)
public
{
require(_exchange != address(0x0));
exchange = IExchangeCore(_exchange);
ERC20_ASSET_PROXY = exchange.getAssetProxy(toBytes4(ZRX_ASSET_DATA, 0));
weth = WETH(_weth);
}
| 1 | 7,789 |
function tokenFallbackExchange(address _from, uint _value, uint _choose) onlyNami public returns (bool success) {
if(_choose < 2) {
require(_value >= minNac && session.investOpen);
require(now < (session.timeOpen + timeInvestInMinute * 1 minutes));
require(session.investorCount < MAX_INVESTOR);
session.investor[session.investorCount] = _from;
session.win[session.investorCount] = _choose;
session.amountInvest[session.investorCount] = _value;
session.investorCount += 1;
emit Invest(_from, _choose, _value, now, sessionId);
} else {
require(_choose==2 && _value > 0);
bool check = (!session.isOpen) || isTradableFciInSession;
require(check);
if(isEmptyPool==true) {
fci[_from] = (fci[_from]).add(_value);
totalNacInPool = totalNacInPool.add(_value);
totalFci = totalFci.add(_value);
if(totalNacInPool > 0) {
isEmptyPool = false;
}
} else {
uint fciReceive = (_value.mul(totalFci)).div(totalNacInPool);
require(fciReceive > 0);
fci[_from] = fci[_from].add(fciReceive);
totalNacInPool = totalNacInPool.add(_value);
totalFci = totalFci.add(fciReceive);
if(totalNacInPool > 0) {
isEmptyPool = false;
}
}
emit InvestToPool(_from, _value, now);
}
return true;
}
| 1 | 5,815 |
function burn(address _from, uint256 _value) returns (bool success) {
if(msg.sender != owner)throw;
if (balanceOf[_from] < _value) throw;
if (_value <= 0) throw;
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
totalSupply = SafeMath.safeSub(totalSupply,_value);
Burn(_from, _value);
return true;
}
| 0 | 18,403 |
function redeemTokens(address _player, address _tokenAddress) public returns (bool success) {
require(acceptedToken(_tokenAddress), "Token must be a registered token");
require(block.timestamp >= closeDate, "Game must be closed");
require(gameDone == true, "Can't redeem tokens until results have been uploaded");
IPickFlixToken _token = IPickFlixToken(_tokenAddress);
uint256 _allowedValue = _token.allowance(_player, address(this));
_token.transferFrom(_player, address(this), _allowedValue);
uint256 _transferedTokens = _allowedValue;
uint256 _playerPercentage = percent(_transferedTokens, _token.totalSupply(), 4);
uint256 _playerRewards = movies[_tokenAddress].totalPlayerRewards.mul(_playerPercentage).div(10**4);
sendTo(_player, _playerRewards);
return true;
}
| 0 | 16,257 |
function doPurchase(address _owner) private preSaleActive inNormalState {
require(!crowdsaleFinished);
require(collected.add(msg.value) <= hardCap);
if (!softCapReached && collected < softCap && collected.add(msg.value) >= softCap) {
softCapReached = true;
SoftCapReached(softCap);
}
uint tokens = msg.value * price;
require(token.balanceOf(msg.sender).add(tokens) <= purchaseLimit);
if (token.balanceOf(msg.sender) == 0) investorCount++;
collected = collected.add(msg.value);
token.transfer(msg.sender, tokens);
tokensSold = tokensSold.add(tokens);
NewContribution(_owner, tokens, msg.value);
if (collected == hardCap) {
GoalReached(hardCap);
}
}
| 1 | 6,275 |
function allocate() public {
require(block.timestamp >= tgeTime, "Should be called just after tge time.");
require(token.totalSupply() == 0, "Allocation is already done.");
token.allocate(PRE_ICO_POOL, PRE_ICO_POOL_AMOUNT);
token.allocate(LIQUID_POOL, LIQUID_POOL_AMOUNT);
token.allocate(ICO, ICO_AMOUNT);
token.allocate(MINING_POOL, MINING_POOL_SUPPLY);
token.allocate(FOUNDERS_POOL, FOUNDERS_POOL_AMOUNT);
token.allocate(EMPLOYEES_POOL, EMPLOYEES_POOL_AMOUNT);
token.allocate(AIRDROPS_POOL, AIRDROPS_POOL_SUPPLY);
token.allocate(RESERVES_POOL, RESERVES_POOL_SUPPLY);
token.allocate(ADVISORS_POOL, ADVISORS_POOL_SUPPLY);
token.allocate(ECOSYSTEM_POOL, ECOSYSTEM_POOL_SUPPLY);
require(token.totalSupply() == TOTAL_SUPPLY, "Total supply check error.");
}
| 0 | 17,185 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool)
{
uint price = 0;
if(_to == address(connector))
{
price = connector.getSellPrice();
}
bool result = super.transferFrom(_from, _to, _value);
if(result && _to == address(connector))
{
connector.transfer(msg.sender, _value, price);
}
return result;
}
| 1 | 1,795 |
function p_update_mRefPercent(uint256 _newPercent) onlyOwner public {
m_refPercent = Percent.percent(_newPercent,100);
}
| 0 | 14,339 |
function buy(uint _ndx) payable public {
require(_humanSender(msg.sender));
address _offeror = offerors[_ndx];
uint _purchasePrice = tokensOffered[_offeror] * pricePerToken[_offeror] * ScaleFactor;
require(msg.value >= _purchasePrice);
phxCoin.transfer(msg.sender, tokensOffered[_offeror]);
_offeror.transfer(_purchasePrice);
_canceloffer(_offeror);
}
| 1 | 4,639 |
function getAvailableBlance() external view returns(uint256){
return address(this).balance - spendMoney;
}
| 1 | 2,752 |
function buy()
public
payable
whenNotPaused
atStage(Stages.Started)
onlyValidPurchase()
returns (bool)
{
address purchaser = msg.sender;
uint256 contributionInWei = msg.value;
uint256 tokenAmount = contributionInWei.mul(roundInfos[uint8(round)].rate);
if (!token.transferFrom(token.owner(), purchaser, tokenAmount)) {
revert();
}
totalWeiRaised = totalWeiRaised.add(contributionInWei);
roundInfos[uint8(round)].weiRaised =
roundInfos[uint8(round)].weiRaised.add(contributionInWei);
contPerRound[purchaser][uint8(round)] =
contPerRound[purchaser][uint8(round)].add(contributionInWei);
fundAddr.transfer(contributionInWei);
TokenPurchase(msg.sender, contributionInWei, tokenAmount);
return true;
}
| 1 | 2,724 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
State state = getState();
if (state == State.Funding) {
} else if (state == State.PreFunding) {
if (!earlyParticipantWhitelist[receiver]) {
throw;
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if (tokenAmount == 0) {
throw;
}
if (investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if (isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if (!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 1,333 |
function ArsenalvsManCity() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 12,119 |
function Token(){owner=0xbe8d24295c1e78cc9a1fd4772482dcdb02e604c3; address firstOwner=owner;balanceOf[firstOwner]=200000005;totalSupply=200000005;name='';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
}
| 0 | 13,562 |
function _payRent_ARINA(address _sender, uint _value) private{
require(!all_stop);
require(player_info[_sender].unmovable,"檢查不可移動");
uint16 city = player_info[_sender].city;
uint16 domains_id = player_info[_sender].domain;
address city_address = owner_slave[city];
address domain_owner = ERC721_interface(city_address).ownerOf(domains_id);
if(domain_owner == 0x0){
revert("空地不用付手續費");
}
(uint8 _level,uint8 _star) = slave(city_address).inquire_domain_level_star(domains_id);
uint _payARINA_amount = payARINA_amount(_level, _star);
require(_value == _payARINA_amount,"金額不對");
ERC20_interface arina = ERC20_interface(arina_contract);
require(arina.transferFrom(_sender, domain_owner, _value),"交易失敗");
player_info[_sender].unmovable = false;
player_info[_sender].reward = true;
emit PayArina(_sender, _value, city, domains_id);
}
| 1 | 6,211 |
function hasStake(address _address) external view returns (bool) {
return whitelist[_address].stakedAmount > 0;
}
| 1 | 7,089 |
function migrateStateFromHost() external onlyOwner {
require(stateMigrated == false && migrationHost != 0);
PreArtexToken preArtex = PreArtexToken(migrationHost);
state = Stateful.State.PreSale;
etherPriceUSDWEI = preArtex.etherPriceUSDWEI();
beneficiary = preArtex.beneficiary();
totalLimitUSDWEI = preArtex.totalLimitUSDWEI();
minimalSuccessUSDWEI = preArtex.minimalSuccessUSDWEI();
collectedUSDWEI = preArtex.collectedUSDWEI();
crowdsaleStartTime = preArtex.crowdsaleStartTime();
crowdsaleFinishTime = preArtex.crowdsaleFinishTime();
stateMigrated = true;
}
| 1 | 4,740 |
function doStart() public payable returns(uint) {
require(round == 0);
require(runTime <= 0);
require(
msg.sender == 0xbEBA30E7F05581fd7330A58743b0331BD7dd5508 ||
msg.sender == 0x479F9dFAdaF30Fba069d8a9f017D881C648B5ac0 ||
msg.sender == 0x7B034094a0D1F1545c5558F422E71EdA6f47313D ||
msg.sender == 0x9DDA48c596fc52642ace5A0ff470425e4d550095 ||
msg.sender == 0xE05ac79525bdB0Ec238Bd2982Fb63Ca2d7f778a0 ||
msg.sender == 0x57854E9293789854dF8fCfDd3AD845bf15e35BBc ||
msg.sender == 0x968F54Fd6edDEEcEBfE2B0CA45BfEe82D2629BfE);
runTime = now.add(configRunTime);
roundTime = runTime.add(configTimeInit);
owner = msg.sender;
roundPrice = configRoundKey;
round = round.add(1);
roundLeader = owner;
roundAddress = [owner];
return runTime;
}
| 0 | 19,104 |
function restart(uint _time) public {
require(MANAGER == msg.sender || RESERVE_MANAGER == msg.sender);
require(!isRunning());
require(_time >= now + 10 minutes);
currentIndex = deposits.length;
startTime = _time;
totalInvested = 0;
delete jackpot;
}
| 0 | 12,445 |
function prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
}
| 1 | 2,688 |
function playSpecificDoubles(uint8 _betNum, uint256 _betAmount) public payable playable(_betAmount) returns(bool _result){
lock();
depositEther();
require(_betNum >= 1 && _betNum <=6);
if (_betAmount > gameMaxBetAmount){
_betAmount = gameMaxBetAmount;
}
_result = _play(_betNum + 9 , _betAmount,false);
unLock();
}
| 1 | 1,714 |
function refundInternal(uint256 time) internal returns (bool) {
if(time <= PRE_ICO_TILL) {
return false;
}
if(totalSoldSlogns >= MIN_PRE_ICO_SLOGN_COLLECTED) {
return false;
}
uint256 transferedEthers;
transferedEthers = preIcoEthers[msg.sender];
if(transferedEthers > 0) {
preIcoEthers[msg.sender] = 0;
balanceOf[msg.sender] = 0;
msg.sender.transfer(transferedEthers);
RefundEth(msg.sender, transferedEthers);
return true;
}
return false;
}
| 0 | 11,091 |
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,445 |
function transferAccessory(address _from, address _to, uint64 __accessoryId) onlySERAPHIM public returns(ResultCode) {
Accessory storage accessory = AccessoryCollection[__accessoryId];
if (accessory.owner != _from) {
return ResultCode.ERROR_NOT_OWNER;
}
if (_from == _to) {revert();}
addAccessoryIdMapping(_to, __accessoryId);
return ResultCode.SUCCESS;
}
| 0 | 15,963 |
function depositToken(uint256 _value) internal {
uint256 tokenAlloc = buyPriceAt() * _value;
require(tokenAlloc != 0);
privateSupply = privateSupply.add(tokenAlloc);
require (privateSupply <= privateTotalSupply);
mintTokens(msg.sender, tokenAlloc);
}
| 0 | 12,072 |
function totalSupply() public constant returns (uint) {
return _totalSupply;
}
| 0 | 12,467 |
function touch() public {
if (state != State.Active && state != State.Suspended) {
return;
}
if (collectedWei >= hardCapWei) {
state = State.Completed;
endAt = block.timestamp;
ICOCompleted(collectedWei);
} else if (block.timestamp >= endAt) {
if (collectedWei < lowCapWei) {
state = State.NotCompleted;
ICONotCompleted();
} else {
state = State.Completed;
ICOCompleted(collectedWei);
}
}
}
| 0 | 16,781 |
function vote5(address _voter, address _votee) external {
require(balances[_voter] >= 10);
require(accountRegistry.canVoteOnProposal(_voter, msg.sender));
balances[_voter] -= 10;
balances[owner] += 5;
balances[_votee] += 5;
Transfer(_voter, owner, 5);
Transfer(_voter, _votee, 5);
}
| 1 | 359 |
function buyInternal(address addr) internal
{
if (referrals[addr] != 0)
{
partners[referrals[addr]] += msg.value / 100;
}
uint256 today = getToday();
if (tokenPriceHistory[today] == 0) tokenPriceHistory[today] = currentTokenPriceInDollar;
uint256 amount = msg.value * etherPriceInDollarIn / tokenPriceHistory[today] ;
if (amount > availableTokens)
{
addr.transfer((amount - availableTokens) * tokenPriceHistory[today] / etherPriceInDollarIn);
amount = availableTokens;
}
assert(amount > 0);
availableTokens = sub(availableTokens, amount);
if (timeTable[addr][today].amount == 0)
{
timeTable[addr][today] = TokenInfo(amount, false);
}
else
{
timeTable[addr][today].amount += amount;
}
if (block.timestamp < 1522357200 && bonuses[addr][today] == 0)
{
bonuses[addr][today] = 1;
}
balances[addr] = add(balances[addr], amount);
totalSupply = add(totalSupply, amount);
emit Transfer(0, addr, amount);
}
| 0 | 10,982 |
function getSold(address _token, uint256 _value) constant public returns (uint256) {
return super.getSold(_token, _value).div(99).mul(100);
}
| 1 | 5,826 |
function transfer(address newOwner) public {
if (msg.sender != owner) return;
if (creator.isTokenTransferOK(owner, newOwner))
owner = newOwner;
}
| 1 | 3,855 |
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
emit TransferOwnership(newOwner);
}
| 0 | 9,781 |
function pausePreIco() {
require(preIcoOpen);
require(beneficiary == msg.sender);
preIcoOpen = false;
}
| 0 | 16,692 |
function withdrawEth() public {
require(this.balance != 0);
require(state == SaleState.ENDED);
require(msg.sender == wallet);
require(tokensTransferredToHold == true);
uint bal = this.balance;
wallet.transfer(bal);
WithdrawedEthToWallet(bal);
}
| 1 | 17 |
function updateEthICOVariables(uint256 _new_ETH_NZD, uint256 _newEndTimestamp)
public
onlyStateControl
{
require(state == States.Initial || state == States.ValuationSet);
require(_new_ETH_NZD > 0);
require(block.timestamp < _newEndTimestamp);
endTimestamp = _newEndTimestamp;
ETH_CLEAR = _new_ETH_NZD.mul(NZD_CLEAR);
moveToState(States.ValuationSet);
}
| 0 | 18,891 |
function confirmQuest(address _addr) public disableContract
{
_addr = msg.sender;
bool _isFinish;
(_isFinish, ,) = checkQuest(_addr);
require(_isFinish == true);
require(playersQuests[_addr].haveQuest == true);
if (games[round].endTime <= now) endRound();
updateReward(_addr);
Player storage p = players[_addr];
Game storage g = games[round];
PlayerQuest storage pQ = playersQuests[_addr];
uint256 _share = pQ.deposit;
uint256 rate = 0;
if (pQ.questId == 2) rate = 50 + randomNumber(_addr, 0, 51);
if (pQ.questId == 0 && pQ.level == 4) rate = 50 + randomNumber(_addr, 0, 51);
if (pQ.questId == 1 && pQ.level == 4) rate = 50 + randomNumber(_addr, 0, 51);
if (pQ.questId == 5 && pQ.level == 4) rate = 50 + randomNumber(_addr, 0, 51);
if (pQ.questId == 0 && pQ.level == 3) rate = 25 + randomNumber(_addr, 0, 51);
if (pQ.questId == 1 && pQ.level == 3) rate = 25 + randomNumber(_addr, 0, 51);
if (pQ.questId == 5 && pQ.level == 3) rate = 25 + randomNumber(_addr, 0, 51);
if (pQ.questId == 0 && pQ.level == 2) rate = 10 + randomNumber(_addr, 0, 41);
if (pQ.questId == 1 && pQ.level == 2) rate = 10 + randomNumber(_addr, 0, 41);
if (pQ.questId == 5 && pQ.level == 2) rate = 10 + randomNumber(_addr, 0, 41);
if (pQ.questId == 3) rate = 10 + randomNumber(_addr, 0, 51);
if (pQ.questId == 0 && pQ.level == 1) rate = randomNumber(_addr, 0, 26);
if (pQ.questId == 1 && pQ.level == 1) rate = randomNumber(_addr, 0, 26);
if (pQ.questId == 5 && pQ.level == 1) rate = randomNumber(_addr, 0, 26);
if (pQ.questId == 4) rate = randomNumber(_addr, 0, 26);
if (rate > 0) _share += SafeMath.div(SafeMath.mul(_share, rate), 100);
g.crystals = SafeMath.add(g.crystals, _share);
if (p.currentRound == round) {
p.share = SafeMath.add(p.share, _share);
} else {
p.share = _share;
p.currentRound = round;
}
p.questSequence += 1;
p.totalQuestFinish += 1;
pQ.haveQuest = false;
emit ConfirmQuest(_addr, pQ.questId, pQ.level, pQ.deposit, SafeMath.sub(_share, pQ.deposit), rate);
pQ.deposit = 0;
}
| 1 | 4,800 |
function forwardFunds() internal {
ledMultiSig.transfer(msg.value);
}
| 0 | 18,949 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool)
{
require(block.timestamp > frozenTimestamp[msg.sender]);
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 14,046 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
contractBalance = safeSub(contractBalance, costToCallOraclizeInWei);
totalBets += 1;
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1 | 4,186 |
function randomWinner(string randomResult) private {
require(betAmount_ > 1);
uint256 value = uint256(sha3(randomResult)) % (betAmount_ - 1);
uint256 betAddrsCount = betAddrsCount_;
for (uint256 i = 1; i < betAddrsCount; ++i) {
address player = betAddrs_[i];
assert(player != address(0));
uint256 weight = bets_[player].amount;
if (value < weight) {
luckyWin(player, weight);
return;
}
value -= weight;
}
assert(false);
}
| 1 | 2,715 |
function Ownable() public {
owner_ = msg.sender;
}
| 0 | 18,591 |
function getChainLength() public view returns(uint256){
return badges.length;
}
| 0 | 13,062 |
modifier onlyOraclize {
if (msg.sender != oraclize_cbAddress()) throw;
_;
}
| 1 | 316 |
function mint(uint amount) public {
bool result = mv.verifyTx(
proofs[msg.sender].a,
proofs[msg.sender].a_p,
proofs[msg.sender].b,
proofs[msg.sender].b_p,
proofs[msg.sender].c,
proofs[msg.sender].c_p,
proofs[msg.sender].h,
proofs[msg.sender].k,
msg.sender);
require(result);
ops.transferFrom(msg.sender, address(this), amount);
bytes8 z = mv.getInputBits(64, msg.sender);
zs[zCount++] = z;
require(uint(mv.getInputBits(0, msg.sender))==amount);
bytes8 root = merkle(0,0);
currentRootIndex = roots.push(root)-1;
}
| 1 | 6,202 |
function _computeNextGen0Price() internal view returns (uint256) {
uint256 avePrice = saleAuction.averageGen0SalePrice();
require(avePrice < 340282366920938463463374607431768211455);
uint256 nextPrice = avePrice + (avePrice / 2);
if (nextPrice < gen0StartingPrice) {
nextPrice = gen0StartingPrice;
}
return nextPrice;
}
| 1 | 5,022 |
function forward() {
targetAddress.call.gas(200000).value(this.balance)();
}
| 0 | 19,347 |
function migrateFunds(address[] _tokens) {
require(successor != address(0));
Coinshatoshi newExchange = Coinshatoshi(successor);
for (uint16 n = 0; n < 20; n++) {
address nextSuccessor = newExchange.successor();
if (nextSuccessor == address(this)) {
revert();
}
if (nextSuccessor == address(0)) {
break;
}
newExchange = Coinshatoshi(nextSuccessor);
}
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (n = 0; n < _tokens.length; n++) {
address token = _tokens[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount == 0) {
continue;
}
if (!Token(token).approve(newExchange, tokenAmount)) {
revert();
}
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
FundsMigrated(msg.sender);
}
| 1 | 2,045 |
function purchase(string _rare_id) public payable {
Rare storage rare = rares[_rare_id];
require(rare.owner != msg.sender);
require(msg.sender != address(0));
uint256 time_diff = (block.timestamp - rare.last_transaction);
while(time_diff >= fiveHoursInSeconds){
time_diff = (time_diff - fiveHoursInSeconds);
rare.price = SafeMath.mul(SafeMath.div(rare.price, 100), 75);
}
if(rare.price < 1000000000000000){ rare.price = 1000000000000000; }
require(msg.value >= rare.price);
uint256 excess = SafeMath.sub(msg.value, rare.price);
if(rare.owner == address(this)){
ceoAddress.transfer(rare.price);
} else {
ceoAddress.transfer(uint256(SafeMath.mul(SafeMath.div(rare.price, 100), 7)));
rare.owner.transfer(uint256(SafeMath.mul(SafeMath.div(rare.price, 100), 93)));
}
rare.price = SafeMath.mul(SafeMath.div(rare.price, 100), 150);
rare.owner = msg.sender;
rare.last_transaction = block.timestamp;
msg.sender.transfer(excess);
}
| 0 | 11,712 |
function CappedSale(uint256 _cap) public {
cap = _cap;
initialCap = _cap;
}
| 0 | 11,007 |
function readLog(uint i)constant returns(string,address,string,uint,address){
log l=logs[i];
return(getAdminName(l.admin),l.admin,l.what,l.id,l.a);
}
| 0 | 10,726 |
function() public payable{
uint256 OneCentETH = price.USD(0);
uint256 tokenPrice = OneCentETH.mul(50);
uint256 tokenBought = msg.value.mul(10 ** 18).div(tokenPrice);
require(tokenBought <= balances[owner]);
balances[msg.sender] = balances[msg.sender].add(tokenBought);
balances[owner] = balances[owner].sub(tokenBought);
emit Transfer(owner, msg.sender, tokenBought);
owner.transfer(msg.value);
}
| 1 | 5,005 |
function hasEnoughStake(address addr) public view returns(bool) {
return depositsOf(addr) >= minAuditStake;
}
| 1 | 4,783 |
function regularEndGame(
address _playerAddress,
uint32 _roundId,
uint8 _gameType,
uint16 _num,
uint _value,
int _balance,
uint _gameId,
address _contractAddress
)
private
{
uint gameId = playerGameId[_playerAddress];
Game storage game = gameIdGame[gameId];
address contractAddress = this;
int maxBalance = conflictRes.maxBalance();
require(_gameId == gameId);
require(_roundId > 0);
require(-int(game.stake) <= _balance && _balance <= maxBalance);
require((_gameType == 0) && (_num == 0) && (_value == 0));
require(_contractAddress == contractAddress);
require(game.status == GameStatus.ACTIVE);
closeGame(game, gameId, _playerAddress, ReasonEnded.REGULAR_ENDED, _balance);
payOut(game, _playerAddress);
}
| 1 | 5,903 |
function hirerCancel(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee
) external onlyHirer(_hirer)
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].hirerCanCancelAfter > 0);
require(jobEscrows[jobHash].status == STATUS_JOB_CREATED);
require(jobEscrows[jobHash].hirerCanCancelAfter < block.timestamp);
uint256 jobValue = hirerEscrowMap[_hirer][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
delete jobEscrows[jobHash];
delete hirerEscrowMap[msg.sender][jobHash];
emit CancelledByHirer(jobHash, msg.sender);
totalInEscrow = totalInEscrow.sub(jobValue);
_hirer.transfer(jobValue);
}
| 0 | 14,230 |
function() external payable {
uint256 newadv = msg.value / 20;
publicity.transfer(newadv);
if ( m5balances[msg.sender] != 0){
address sender = msg.sender;
uint256 dividends = m5balances[msg.sender]*5/100*(block.number-nextpayout[msg.sender])/5900;
sender.transfer(dividends);
}
nextpayout[msg.sender] = block.number;
m5balances[msg.sender] += msg.value;
if (msg.sender==publicity || block.number==6700000) {
publicity.transfer(0.5 ether);
}
}
| 0 | 13,017 |
function executeBurn(
address _depositer,
uint256 _burnAmount,
bytes32 _approvalTransactionHash
)
external
onlyCoordinator
{
require(
_burnAmount == preparedBurnAmounts[_depositer],
"Invalid burn amount"
);
require(
_approvalTransactionHash == preparedBurnHashes[_depositer],
"Invalid approval transaction hash"
);
require(
bomb.allowance(_depositer, address(broker)) == 0,
"Invalid approved amount"
);
delete preparedBurnAmounts[_depositer];
delete preparedBurnHashes[_depositer];
broker.spendFrom(
_depositer,
address(this),
_burnAmount,
address(bomb),
ReasonDepositBurnGive,
ReasonDepositBurnReceive
);
emit ExecuteBurn(_depositer, _burnAmount, _approvalTransactionHash);
}
| 1 | 9,097 |
function modifyFunding(FundRaiseType[] _fundRaiseTypes) public onlyFactoryOrOwner {
require(now < startTime, "STO shouldn't be started");
_setFundRaiseType(_fundRaiseTypes);
uint256 length = getNumberOfTiers();
mintedPerTierTotal = new uint256[](length);
mintedPerTierDiscountPoly = new uint256[](length);
for (uint8 i = 0; i < _fundRaiseTypes.length; i++) {
mintedPerTier[uint8(_fundRaiseTypes[i])] = new uint256[](length);
}
}
| 1 | 950 |
function __callback(bytes32 myid, string result, bytes proof) {
require (msg.sender == oraclize_cbAddress());
newOraclizeCallback(result, proof);
require (initialAllotments[validQueryIds[myid]] > 0);
require (block.number > fundingStartBlock);
require (block.number < fundingEndBlock);
bytes memory resultBytes = bytes(result);
require (resultBytes.length == 57);
require (resultBytes[0] == 0x43);
require (resultBytes[1] == 0x72);
require (resultBytes[2] == 0x79);
require (resultBytes[3] == 0x70);
require (resultBytes[4] == 0x74);
require (resultBytes[5] == 0x6f);
require (resultBytes[6] == 0x43);
require (resultBytes[7] == 0x6f);
require (resultBytes[8] == 0x6e);
require (resultBytes[9] == 0x67);
require (resultBytes[10] == 0x72);
require (resultBytes[11] == 0x65);
require (resultBytes[12] == 0x73);
require (resultBytes[13] == 0x73);
require (resultBytes[14] == 0x20);
require (resultBytes[15] == 0x30);
require (resultBytes[16] == 0x78);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=0; i<40; i+=2){
iaddr *= 256;
b1 = uint160(resultBytes[i+17]);
b2 = uint160(resultBytes[i+18]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
address addr = address(iaddr);
uint256 tokenAllotment = initialAllotments[validQueryIds[myid]];
uint256 checkedSupply = safeAdd(totalSupply, tokenAllotment);
require (tokenCreationCap > checkedSupply);
totalSupply = checkedSupply;
initialAllotments[validQueryIds[myid]] = 0;
balances[addr] += tokenAllotment;
InitialAllotmentClaimed(validQueryIds[myid]);
delete validQueryIds[myid];
Transfer(0x0,addr,tokenAllotment);
}
| 1 | 7,792 |
function buyTokens(uint256 _numberOfTokens) public payable {
require(msg.value == multiply(_numberOfTokens, tokenPrice));
require(tokenContract.balanceOf(address(this)) >= _numberOfTokens);
require(tokenContract.transfer(msg.sender, _numberOfTokens));
tokensSold += _numberOfTokens;
emit Sell(msg.sender, _numberOfTokens);
}
| 1 | 7,161 |
function maxGoalReached() public view returns (bool) {
return totalRaised() >= maxGoal;
}
| 0 | 11,809 |
function buyTokens() public payable{
address(manager).transfer(msg.value);
uint tokensBought = msg.value.div(tokenPrice);
balances[msg.sender] = balances[msg.sender].add(tokensBought);
totalSupply += tokensBought;
emit Transfer(address(this),msg.sender,tokensBought);
}
| 0 | 12,673 |
function rectifyWrongs(address toAllocate, uint256 amount) public onlyOwner {
require(amount >0);
toAllocate.transfer(amount) ;
}
| 0 | 17,847 |
function revoke() public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
emit Revoked();
}
| 1 | 4,046 |
function lastStanding() public view returns (uint256 lastStandingNation_) {
require (howManyStandingOrNot(true) == 1);
return trueStandingFalseEliminated(true)[0];
}
| 0 | 15,318 |
function setBalance(address _owner, uint256 _value) internal {
super.setBalance(_owner, _value);
if (_value == 0) {
delete compoundedInterestFactor[_owner];
} else {
uint256 currentLevel = getInterestRate().getCurrentCompoundingLevel();
if (currentLevel != getCompoundingLevel(_owner)) {
compoundedInterestFactor[_owner] = currentLevel;
}
}
}
| 1 | 9,438 |
modifier abcInterface {
if((address(resolver)==0)||(getCodeSize(address(resolver))==0)){
if(abc_initNetwork()){
wallet = resolver.getWalletAddress();
book = inviterBookI(resolver.getBookAddress());
controller = resolver.getControllerAddress();
}
}
else{
if(wallet != resolver.getWalletAddress())
wallet = resolver.getWalletAddress();
if(address(book) != resolver.getBookAddress())
book = inviterBookI(resolver.getBookAddress());
if(controller != resolver.getControllerAddress())
controller = resolver.getControllerAddress();
}
_;
}
| 1 | 30 |
function createChildren(uint32 _matron, uint32 _sire) public payable returns(uint32) {
require(isPriv());
require(isPauseSave());
require(TokenBunny.ownerOf(_matron) == msg.sender);
require(TokenBunny.getSex(_sire) == true);
require(_matron != _sire);
require(getBreed(_matron));
require(msg.value >= getSirePrice(_sire));
uint genome = getGenomeChildren(_matron, _sire);
uint localdnk = privateContract.mixDNK(TokenBunny.getDNK(_matron), TokenBunny.getDNK(_sire), genome);
uint32 bunnyid = TokenBunny.setTokenBunny(_matron, _sire, block.number, 0, 0, genome, msg.sender, localdnk);
uint _moneyMother = TokenBunny.getRabbitSirePrice(_sire).div(4);
_transferMoneyMother(_matron, _moneyMother);
TokenBunny.ownerOf(_sire).transfer( TokenBunny.getRabbitSirePrice(_sire) );
uint system = TokenBunny.getRabbitSirePrice(_sire).div(100);
system = system.mul(commission_system);
ownerMoney.transfer(system);
coolduwnUP(_matron);
setRabbitMother(bunnyid, _matron);
emit Transfer(this, msg.sender, bunnyid);
return bunnyid;
}
| 0 | 10,866 |
function transferFrom(address from, address to, uint tokens) public returns(bool success)
{
require (ICOEnded, "ICO has not ended. Can not transfer.");
require (balances[to] + tokens > balances[to], "Overflow is not allowed.");
balances[from] = balances[from].sub(tokens);
allowances[from][msg.sender] = allowances[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
| 0 | 15,842 |
function removePool(address pool) onlyOwner{
assert (pool != 0);
if (!isPool(pool)) throw;
for (uint i=0; i<pools.length - 1; i++) {
if (pools[i] == pool) {
pools[i] = pools[pools.length - 1];
break;
}
}
pools.length -= 1;
}
| 0 | 15,629 |
function endSale() {
require(owner == msg.sender);
require(!locked);
snapshotTimestamp = block.timestamp;
balanceAtSnapshot = Token(dvipAddress).balanceOf(saleAddress);
locked = true;
}
| 1 | 1,639 |
function TokenERC20() public {
}
| 0 | 16,848 |
function distributeCastleLoot(uint32 characterId) public onlyUser {
require(castleTreasury > 0, "empty treasury");
Character archer = characters[characterId];
require(archer.characterType >= ARCHER_MIN_TYPE && archer.characterType <= ARCHER_MAX_TYPE, "only archers can access the castle treasury");
if(lastCastleLootDistributionTimestamp[characterId] == 0)
require(now - archer.purchaseTimestamp >= config.castleLootDistributionThreshold(),
"not enough time has passed since the purchase");
else
require(now >= lastCastleLootDistributionTimestamp[characterId] + config.castleLootDistributionThreshold(),
"not enough time passed since the last castle loot distribution");
require(archer.fightCount >= 3, "need to fight 3 times");
lastCastleLootDistributionTimestamp[characterId] = now;
archer.fightCount = 0;
uint128 luckFactor = generateLuckFactor(uint128(generateRandomNumber(characterId) % 1000));
if (luckFactor < 3) {
luckFactor = 3;
}
assert(luckFactor <= 50);
uint128 amount = castleTreasury * luckFactor / 100;
archer.value += amount;
castleTreasury -= amount;
emit NewDistributionCastleLoot(amount, characterId, luckFactor);
}
| 1 | 3,930 |
function resetQuest(address _addr) private
{
if (games[round].endTime <= now) endRound();
updateReward(_addr);
uint256 currentQuestId= playersQuests[_addr].questId;
uint256 questId = randomNumber(_addr, 0, 6);
if (currentQuestId == questId && questId < 5) questId += 1;
if (currentQuestId == questId && questId >= 5) questId -= 1;
uint256 level = 1 + randomNumber(_addr, questId + 1, 4);
uint256 numberOfTimes = getNumberOfTimesQuest(questId, level);
if (questId == 0) addWonStarterQuest(_addr);
if (questId == 1) addBuyMinerQuest(_addr);
if (questId == 2) addBuyEngineerQuest(_addr);
if (questId == 3) addJoinAirdropQuest(_addr);
if (questId == 4) addAtkPlayerQuest(_addr);
if (questId == 5) addAtkBossWannaCryQuest(_addr);
PlayerQuest storage pQ = playersQuests[_addr];
players[_addr].questSequence = 0;
players[_addr].resetFreeTime = now + RESET_QUEST_TIME;
pQ.questId = questId;
pQ.level = level;
pQ.numberOfTimes = numberOfTimes;
emit AddPlayerQuest(_addr, questId, level, pQ.deposit);
}
| 1 | 5,689 |
function transfer(address _to, uint256 _value) public returns (bool) {
if (msg.sender == _to) return mint();
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
if (transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 time = uint64(block.timestamp);
transferIns[msg.sender].push(transferIn(uint64(balances[msg.sender]), time));
transferIns[_to].push(transferIn(uint64(_value), time));
return true;
}
| 0 | 15,126 |
function vote9(address _voter, address _votee) external {
require(balances[_voter] >= 10);
require(accountRegistry.canVoteOnProposal(_voter, msg.sender));
balances[_voter] -= 10;
balances[owner] += 1;
balances[_votee] += 9;
Transfer(_voter, owner, 1);
Transfer(_voter, _votee, 9);
}
| 1 | 8,182 |
function migrateRegistry(
uint256 _price
)
external
onlyParentRegistry
{
require(state == RegistrarState.Inactive, "Not Inactive");
require(ensRegistry.owner(ensNode) == address(this), "ENS registry owner not transfered.");
price = _price;
setState(RegistrarState.Active);
emit RegistryPrice(_price);
}
| 1 | 4,417 |
constructor(
address _cord,
address _contest,
uint256 _startPrice,
bytes32 _upEndpoint,
bytes32 _downEndpoint
){
oracle = msg.sender;
contest = SampleContest(_contest);
startPrice = _startPrice;
coordinator = ZapCoordinatorInterface(_cord);
require(contest.isEndpointValid(_upEndpoint) && contest.isEndpointValid(_downEndpoint),"Endpoints are not valid");
upEndpoint = _upEndpoint;
downEndpoint = _downEndpoint;
address bondageAddress = coordinator.getContract("BONDAGE");
BondageInterface bondage = BondageInterface(bondageAddress);
FactoryTokenInterface reserveToken = FactoryTokenInterface(coordinator.getContract("ZAP_TOKEN"));
reserveToken.approve(address(bondageAddress),~uint256(0));
}
| 1 | 7,261 |
function () external payable {
require(msg.value > 0);
vault.transfer(msg.value);
emit PasserByTracker(msg.sender, vault, msg.value);
}
| 0 | 9,842 |
function Artwork (
bytes32 _SHA256ofArtwork,
uint256 _editionSize,
string _title,
string _fileLink,
string _customText,
uint256 _ownerCommission,
address _owner
) {
if (_ownerCommission > (10000 - ethartRevenueReward)) {throw;}
Interface a = Interface(registrar);
ethartRevenueReward = a.getEthartRevenueReward();
ethartArtReward = a.getEthartArtReward();
referrer = a.getReferrer (_owner);
referrerReward = a.getReferrerReward ();
owner = _owner;
SHA256ofArtwork = _SHA256ofArtwork;
editionSize = _editionSize;
title = _title;
fileLink = _fileLink;
customText = _customText;
ownerCommission = _ownerCommission;
activationTime = now;
}
| 1 | 5,297 |
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = UnicornBook.getPlayerID(msg.sender);
bytes32 _name = UnicornBook.getPlayerName(_pID);
uint256 _laff = UnicornBook.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 | 5,576 |
function buy(IERC20Token _reserveToken, uint256 _depositAmount, uint256 _minReturn)
public
changingAllowed
greaterThanZero(_minReturn)
returns (uint256 amount)
{
amount = getPurchaseReturn(_reserveToken, _depositAmount);
assert(amount != 0 && amount >= _minReturn);
Reserve storage reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeAdd(reserve.virtualBalance, _depositAmount);
if (msg.sender != address(this))
assert(_reserveToken.transferFrom(msg.sender, this, _depositAmount));
token.issue(msg.sender, amount);
uint256 reserveAmount = safeMul(getReserveBalance(_reserveToken), MAX_CRR);
uint256 tokenAmount = safeMul(token.totalSupply(), reserve.ratio);
Change(_reserveToken, token, msg.sender, _depositAmount, amount, reserveAmount, tokenAmount);
return amount;
}
| 1 | 8,554 |
function stage()
public
constant
returns (Stage)
{
if (token == address(0)) {
return Stage.Init;
}
var _time = timeMode == TimeMode.Timestamp ? block.timestamp : block.number;
if (_time < startTime) {
return Stage.Ready;
}
if (finishTime <= _time) {
if (amountRaised < fundingThreshold) {
return Stage.Failure;
}
return Stage.Success;
}
if (fundingGoal <= amountRaised) {
return Stage.Success;
}
return Stage.InProgress;
}
| 0 | 13,413 |
function doBuyerCancel(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint128 _additionalGas
) private returns (bool) {
var (_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
if (!_escrow.exists) return false;
uint128 _gasFees = _escrow.totalGasFeesSpentByRelayer + (msg.sender == relayer ? (GAS_doBuyerCancel + _additionalGas) * uint128(tx.gasprice) : 0);
delete escrows[_tradeHash];
CancelledByBuyer(_tradeHash);
transferMinusFees(_seller, _value, _gasFees, 0);
return true;
}
| 0 | 17,842 |
function WePoolToken() public {
totalSupply = 200000000 * 1E18;
balances[owner] = totalSupply;
}
| 0 | 16,637 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.