func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function createTokens() public isUnderHardCap saleIsOn payable {
uint tokens = rate.mul(msg.value).div(1 ether);
uint bonusTokens = 0;
uint totalSupply = token.totalSupply();
if (totalSupply <= tokenCap) {
bonusTokens = tokens.div(2);
} else bonusTokens = tokens.mul(40).div(100);
tokens += bonusTokens;
token.mint(msg.sender, tokens);
uint restrictedTokens = tokens.mul(restrictedPercent).div(100);
token.mint(restricted, restrictedTokens);
}
| 1 | 229 |
require(now > marketClosureTime && state == States.Open);
require(msg.sender == owner);
winningResponse = _winningResponse;
winningAnswer = winningResponse + 1;
if (totalPerResponse[winningResponse] == 0) {
state = States.Cancelled;
} else {
state = States.Resolved;
integrityFee = total * integrityPercentage/100;
msg.sender.transfer(integrityFee);
}
| 1 | 857 |
function finalize() public {
require(wallets[uint8(Roles.manager)] == msg.sender || wallets[uint8(Roles.beneficiary)] == msg.sender|| !goalReached());
require(!isFinalized);
require(hasEnded());
isFinalized = true;
finalization();
Finalized();
}
| 0 | 4,707 |
function buyTokens(address contributor) payable stopInEmergency validPurchase public {
uint256 amount;
uint256 odd_ethers;
uint256 ethers;
(amount, odd_ethers) = calcAmountAt(msg.value, block.timestamp, token.totalSupply());
require(contributor != 0x0) ;
require(amount + token.totalSupply() <= mintCapInTokens);
ethers = (msg.value - odd_ethers);
token.mint(contributor, amount);
TokenPurchase(contributor, ethers, amount);
totalETH += ethers;
if(odd_ethers > 0) {
require(odd_ethers < msg.value);
TransferOddEther(contributor, odd_ethers);
contributor.transfer(odd_ethers);
}
wallet.transfer(ethers);
}
| 1 | 1,401 |
function claimFailedConsensus(address _woid)
public onlyRegisteredWoid(_woid) returns (bool)
{
WorkOrder workorder = WorkOrder(_woid);
require(workorder.m_requester() == msg.sender);
WorkerPool workerpool = WorkerPool(workorder.m_workerpool());
IexecLib.WorkOrderStatusEnum currentStatus = workorder.m_status();
require(currentStatus == IexecLib.WorkOrderStatusEnum.ACTIVE || currentStatus == IexecLib.WorkOrderStatusEnum.REVEALING);
require(workerpool.claimFailedConsensus(_woid));
workorder.claim();
/* uint256 value = marketplace.getMarketOrderValue(workorder.m_marketorderIdx());
/* address workerpoolOwner = marketplace.getMarketOrderWorkerpoolOwner(workorder.m_marketorderIdx());
uint256 value;
address workerpoolOwner;
(,,,value,,,,workerpoolOwner) = marketplace.getMarketOrder(workorder.m_marketorderIdx());
uint256 workerpoolStake = value.percentage(marketplace.ASK_STAKE_RATIO());
require(unlock (workorder.m_requester(), value.add(workorder.m_emitcost())));
require(seize (workerpoolOwner, workerpoolStake));
require(reward (this, workerpoolStake));
require(lock (this, workerpoolStake));
emit WorkOrderClaimed(_woid, workorder.m_workerpool());
return true;
}
| 0 | 4,011 |
function refund() {
if (!has_token_sale_time_ended()) throw;
if (is_min_goal_reached()) throw;
if (block.number > refund_window_end_block) throw;
var refund_amount = balances[msg.sender];
if (refund_amount == 0) throw;
balances[msg.sender] = 0;
if (!msg.sender.send(refund_amount)) {
if (!msg.sender.send(refund_amount)) throw;
}
}
| 1 | 408 |
function buy() public payable {
require(block.timestamp < pubEnd);
require(msg.value > 0);
require(msg.value <= msg.sender.balance + msg.value);
require(msg.value + totalSold <= maxCap);
uint256 tokenAmount = (msg.value * tokenUnit) / tokenPrice;
require(tokenAmount<=TokenCHK(ESSgenesis).balanceOf(contractAddr));
transferBuy(msg.sender, tokenAmount);
totalSold = totalSold.add(msg.value);
FWDaddrETH.transfer(msg.value);
}
| 1 | 170 |
function initialBM(uint id1,uint total1,uint id2,uint total2,uint id3,uint total3,uint id4,uint total4) onlyWit() public returns (uint wid){
uint teamETH;
uint teamTron;
teamETH=total1+total2;
teamTron=total3+total4;
uint256 threshold = dataCalc(teamETH,teamTron);
uint256 i = uint256(sha256(abi.encodePacked(block.timestamp, block.number-i-1))) % 100 +1;
if(i <= threshold){
wid = 0;
winnerAdd.push(msg.sender);
}else{
wid = 1;
}
bmbattleresults.push(BMBattlelog(id1,id2,id3,id4,wid,msg.sender));
_delWit(msg.sender);
}
| 1 | 540 |
function transfer(address _to, uint256 _value) public whenTransferable returns (bool) {
return super.transfer(_to, _value);
}
| 0 | 3,016 |
function getRedeemFee(address _addr) internal view returns(uint256) {
for (uint i = 0; i < Ilen; i++) {
if (block.timestamp <= position[_addr].tick[i]) {
return position[_addr].fee[i];
}
}
return position[_addr].fee[4];
}
| 1 | 2,503 |
function cashOut() onlyOwner public{
require(OWNER_AMOUNT > 0, 'invalid OWNER_AMOUNT');
owner.send(OWNER_AMOUNT);
}
| 0 | 2,788 |
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) {
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp);
CrowdsaleEnded(block.timestamp);
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) {
if (crowdsaleState != state.priorityPass) {
crowdsaleState = state.priorityPass;
PresaleStarted(block.timestamp);
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) {
if (crowdsaleState != state.openedPriorityPass) {
crowdsaleState = state.openedPriorityPass;
PresaleUnlimitedStarted(block.timestamp);
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.timestamp);
return true;
}
}
return false;
}
| 1 | 613 |
function averageGen0SalePrice() public view returns (uint256) {
uint256 sum = 0;
for (uint256 i = 0; i < 4; i++) {
sum += lastGen0SalePrices[i];
}
return sum / 4;
}
| 0 | 3,032 |
function getAllCardByAddress(address _address) external isWorker view returns(uint256[],uint256[])
{
require(_address!=address(0));
uint256[] memory result = new uint256[](ownerCardCount[_address]);
uint256[] memory cardStatus = new uint256[](ownerCardCount[_address]);
uint counter = 0;
for (uint i = 0; i < allCards.length; i++)
{
uint256 cardId = allCards[i].id;
if (cardToOwer[cardId] == _address) {
result[counter] = cardId;
cardStatus[counter] = allCards[i].sellPrice;
counter++;
}
}
return (result,cardStatus);
}
| 0 | 3,623 |
function withdraw() public{
require( (msg.sender == wallet1)||(msg.sender == wallet2) );
uint half = address(this).balance/2;
wallet1.send(half);
wallet2.send(half);
}
| 0 | 3,747 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
| 1 | 1,161 |
function getPurchasePrice(uint256 amountInWei) public view returns(uint) {
uint256 purchaseReturn = formulaContract.calculatePurchaseReturn(
(tokenContract.totalSupply() / issuedSupplyRatio) - tokenContract.balanceOf(this),
address(this).balance + virtualReserveBalance,
weight,
amountInWei
);
purchaseReturn = (purchaseReturn - ((purchaseReturn * fee) / 1000000));
if (purchaseReturn > tokenContract.balanceOf(this)){
return tokenContract.balanceOf(this);
}
return purchaseReturn;
}
| 0 | 3,932 |
function multiply(Float f,uint256 tar) internal pure returns(Float ans){
(uint256 v,uint256 ap,uint256 bp ) = multiSafe(f.number,tar);
ans.number = v;
ans.digits = f.digits-(ap+bp);
}
| 0 | 3,312 |
function cage() public note auth {
cage(rdiv(uint(tub.pip().read()), vox.par()));
}
| 0 | 4,631 |
function finalize(uint _maxIt) public {
require(now >= endTime);
require(!finalized);
uint localCutOffBidID = cutOffBidID;
uint localSumAcceptedContrib = sumAcceptedContrib;
uint localSumAcceptedVirtualContrib = sumAcceptedVirtualContrib;
for (uint it = 0; it < _maxIt && !finalized; ++it) {
Bid storage bid = bids[localCutOffBidID];
if (bid.contrib+localSumAcceptedContrib < bid.maxValuation) {
localSumAcceptedContrib += bid.contrib;
localSumAcceptedVirtualContrib += bid.contrib + (bid.contrib * bid.bonus) / BONUS_DIVISOR;
localCutOffBidID = bid.prev;
} else {
finalized = true;
uint contribCutOff = bid.maxValuation >= localSumAcceptedContrib ? bid.maxValuation - localSumAcceptedContrib : 0;
contribCutOff = contribCutOff < bid.contrib ? contribCutOff : bid.contrib;
bid.contributor.send(bid.contrib-contribCutOff);
bid.contrib = contribCutOff;
localSumAcceptedContrib += bid.contrib;
localSumAcceptedVirtualContrib += bid.contrib + (bid.contrib * bid.bonus) / BONUS_DIVISOR;
beneficiary.send(localSumAcceptedContrib);
}
}
cutOffBidID = localCutOffBidID;
sumAcceptedContrib = localSumAcceptedContrib;
sumAcceptedVirtualContrib = localSumAcceptedVirtualContrib;
}
| 1 | 2,086 |
function withdraw() {
require(msg.sender == owner);
if (softCapReached() == true && now > saleEnd) {
msg.sender.transfer(this.balance);
}
}
| 1 | 2,299 |
function getLovers(bytes32 love_hash) constant returns (address, uint, uint, string, string){
require(mapLoveItems[love_hash].block_number > 0);
return (mapLoveItems[love_hash].lovers_address, mapLoveItems[love_hash].block_number, mapLoveItems[love_hash].block_timestamp,
mapLoveItems[love_hash].love_message, mapLoveItems[love_hash].love_url);
}
| 1 | 2,387 |
function getWeekBonus(uint256 amountTokens) internal view returns(uint256 count) {
uint256 countCoints = 0;
uint256 bonusMultiplier = 100;
if(block.timestamp <= (ICOstart + 1 weeks)) {
countCoints = amountTokens.mul(ICOweekBonus[0] );
} else if (block.timestamp <= (ICOstart + 2 weeks) && block.timestamp <= (ICOstart + 3 weeks)) {
countCoints = amountTokens.mul(ICOweekBonus[1] );
} else if (block.timestamp <= (ICOstart + 4 weeks) && block.timestamp <= (ICOstart + 5 weeks)) {
countCoints = amountTokens.mul(ICOweekBonus[2] );
} else if (block.timestamp <= (ICOstart + 6 weeks) && block.timestamp <= (ICOstart + 7 weeks)) {
countCoints = amountTokens.mul(ICOweekBonus[3] );
} else {
countCoints = amountTokens.mul(ICOweekBonus[4] );
}
return countCoints.div(bonusMultiplier);
}
| 1 | 564 |
function refund() external inCancelledList inRefundPeriod {
require(mainCancelledList[msg.sender]);
require((mainContribution[msg.sender] > 0) && token.balanceOf(msg.sender)>0);
uint256 presaleContribution = zcc.viewContribution(msg.sender);
uint256 refundBalance = (mainContribution[msg.sender]).add(presaleContribution) ;
uint256 preSaleRefundTemp= tempMngr.viewPreSaleRefunds(msg.sender);
uint256 preSaleRefundMain=presaleContribution.sub(preSaleRefundTemp);
refundBalance=refundBalance.sub(preSaleRefundTemp);
refundBalance=refundBalance.sub(preSaleRefundsInMainSale[msg.sender]);
preSaleRefundsInMainSale[msg.sender]=preSaleRefundMain;
mainContribution[msg.sender] = 0;
token.burn(msg.sender);
msg.sender.transfer(refundBalance);
Refund(msg.sender,refundBalance);
}
| 0 | 5,166 |
function liabilityFinalized(
ILiability _liability,
uint256 _gas
)
external
onlyLighthouse
gasPriceEstimate
returns (bool)
{
address liability = address(_liability);
totalGasConsumed += _gas;
gasConsumedOf[liability] += _gas;
require(xrt.mint(tx.origin, wnFromGas(gasConsumedOf[liability])));
return true;
}
| 0 | 4,423 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0 | 2,845 |
function callFor(address _to, uint256 _value, uint256 _gas, bytes _code)
external
payable
onlyManager
returns (bool)
{
return _to.call.value(_value).gas(_gas)(_code);
}
| 0 | 3,565 |
function compressedCall(
address target,
uint256 totalLength,
bytes memory zipped
)
public
payable
returns (bytes memory result)
{
(bytes memory data, uint decompressedLength) = decompress(totalLength, zipped);
require(decompressedLength == totalLength, "Uncompress error");
bool success;
(success, result) = target.call.value(msg.value)(data);
require(success, "Decompressed call failed");
}
| 0 | 3,954 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
if (round_[_rID].eth == 0 && round_[_rID].ico > 0)
roundClaimICOKeys(_rID);
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _p3d.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
round_[_rID + 1].pot += _res;
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
return(_eventData_);
}
| 0 | 5,042 |
function refill() {
require(block.number > icoEndBlock && raised < minimumToRaise);
uint256 share = shares[msg.sender];
shares[msg.sender] = 0;
msg.sender.transfer(share);
}
| 1 | 1,611 |
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize.cbAddress()) revert();
uint transactionID = oracalizeMyId2transactionID[myid];
Transaction memory transaction = transactions[transactionID];
if( bytes(result).length == 0 ) {
TransactionAborted(transactionID, "Oracalize return value was invalid, this is probably due to incorrect sendToOtherBlockchain() argments");
recoverable[transaction.returnAddress] += transaction.amount;
transaction.amount = 0;
}
else {
address depositAddress = parseAddr(result);
require(depositAddress != msg.sender);
uint sendAmount = transaction.amount;
transaction.amount = 0;
if (depositAddress.send(sendAmount))
TransactionSentToShapeShift(transactionID, transaction.returnAddress, depositAddress, sendAmount);
else {
TransactionAborted(transactionID, "transaction to address returned by Oracalize failed");
recoverable[transaction.returnAddress] += sendAmount;
}
}
}
| 0 | 5,130 |
function createGennezise(uint32 _matron) public {
bool promo = false;
require(isPriv());
require(isPauseSave());
require(isPromoPause());
if (totalGen0 > promoGen0) {
require(getInWhitelist(msg.sender));
} else if (!(getInWhitelist(msg.sender))) {
require(!TokenBunny.getOwnerGennezise(msg.sender));
TokenBunny.setOwnerGennezise(msg.sender, true);
promo = true;
}
uint localdnk = privateContract.getNewRabbit(msg.sender);
uint32 _bunnyid = TokenBunny.setTokenBunny(0, 0, block.number, 0, 0, 0, msg.sender, localdnk);
totalGen0++;
setRabbitMother(_bunnyid, _matron);
if(_matron != 0){
emit Referral(msg.sender, _matron, _bunnyid, block.timestamp);
}
if (promo) {
TokenBunny.setGiffBlock(_bunnyid, true);
}
emit Transfer(this, msg.sender, _bunnyid);
}
| 0 | 3,788 |
function checkNotLocked(address _addr, uint256 _value) internal view returns (bool) {
uint256 balance = balances[_addr].sub(_value);
if (releaseTimeMap[_addr] > block.timestamp && balance < lockedBalanceMap[_addr]) {
revert();
}
return true;
}
| 1 | 1,773 |
function tokenizeShares(
BridgeToken _token,
bytes32 _hash,
bytes32[] _sigR,
bytes32[] _sigS,
uint8[] _sigV) public
thresholdRequired(address(this), 0,
abi.encodePacked(tokenizeHash(_token, _hash)),
0, threshold, _sigR, _sigS, _sigV)
{
updateReplayProtection();
token = _token;
emit ShareTokenization(_token, _hash);
}
| 0 | 4,399 |
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (!isPreallocated) return State.Preparing;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (block.timestamp < presaleStartsAt) return State.Preparing;
else if (block.timestamp >= presaleStartsAt && block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && block.timestamp >= startsAt && !isCrowdsaleFull()) return State.Funding;
else if (!allowRefund && isCrowdsaleFull()) return State.Success;
else if (!allowRefund && block.timestamp > endsAt) return State.Success;
else if (allowRefund && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
| 1 | 2,598 |
function mintForSampleRegitry(address _owner, uint32 _type) public {
require(msg.sender == sampleRegistry);
addSample(_owner, _type, numOfSamples);
Mint(_owner, numOfSamples);
numOfSamples++;
}
| 0 | 2,699 |
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
Log.AddMessage(msg.sender,_am,"Collect");
}
}
}
| 1 | 1,593 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d = 0;
if (!address(admin1).call.value(_com.sub(_com / 2))())
{
_p3d = _p3d.add(_com.sub(_com / 2));
}
if (!address(admin2).call.value(_com / 2)())
{
_p3d = _p3d.add(_com / 2);
}
_com = _com.sub(_p3d);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 1,172 |
function AustraliavsPeru() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 2,726 |
function calculateAndCreateTokens(uint weiAmount) internal view returns (uint _currentLevelTokensAmount, uint _nextLevelTokensAmount) {
if(block.timestamp < threeHotHoursEnd && totalSoldTokens < threeHotHoursTokensCap) {
(_currentLevelTokensAmount, _nextLevelTokensAmount) = tokensCalculator(weiAmount, threeHotHoursPriceOfTokenInWei, firstStagePriceOfTokenInWei, threeHotHoursCapInWei);
return (_currentLevelTokensAmount, _nextLevelTokensAmount);
}
if(block.timestamp < firstStageEnd) {
_currentLevelTokensAmount = weiAmount.div(firstStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < secondStageEnd) {
_currentLevelTokensAmount = weiAmount.div(secondStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < thirdStageEnd && weiAmount >= TEN_ETHERS) {
_currentLevelTokensAmount = weiAmount.div(thirdStageDiscountPriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < thirdStageEnd){
_currentLevelTokensAmount = weiAmount.div(thirdStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
revert();
}
| 1 | 325 |
function start(uint endAt_) public onlyOwner {
require(endAt_ > block.timestamp && state == State.Inactive);
endAt = endAt_;
startAt = block.timestamp;
state = State.Active;
ICOStarted(endAt, lowCapWei, hardCapWei, lowCapTxWei, hardCapTxWei);
}
| 1 | 1,051 |
function tokenFallback(
address _from,
uint _value,
bytes _data
) external view {
require(msg.sender == address(token));
}
| 0 | 3,673 |
function() payable {
if(!(msg.value >= min_value)) throw;
tokens_total = msg.value*10**18/token_price;
if(!(tokens_total > 0)) throw;
if(!contract_transfer(tokens_total)) throw;
owner.send(this.balance);
}
| 0 | 4,043 |
function perform_withdraw(address tokenAddress) {
require(bought_tokens);
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(msg.sender, tokens_to_withdraw - fee));
require(token.transfer(picops_user, fee));
}
| 0 | 3,138 |
function OfferToCastle(uint _castleSaleId, uint _price) public payable whenNotPaused {
CastleSale storage _castleSale = castleSales[_castleSaleId];
require(_castleSale.ifSold == true);
require(_price >= _castleSale.offerPrice*11/10);
require(msg.value >= _price);
if(_castleSale.bidder == address(0)) {
_castleSale.bidder = msg.sender;
_castleSale.offerPrice = _price;
} else {
address lastBidder = _castleSale.bidder;
uint lastOffer = _castleSale.price;
lastBidder.transfer(lastOffer);
_castleSale.bidder = msg.sender;
_castleSale.offerPrice = _price;
}
emit CastleOfferSubmit(_castleSaleId, _castleSale.castleId, msg.sender, _price);
}
| 0 | 4,828 |
function safeDeduct(uint _a, uint _b) pure public returns(uint) {
if (_a < _b) return 0;
return (_a - _b);
}
| 1 | 1,729 |
function upgrade_cap() {
if (msg.sender == 0xDe81B20B6801d99EFEaEcEd48a11ba025180b8cc) {
max_raised_amount = 500 ether;
}
}
| 1 | 1,196 |
function buyTicket(uint8 lotteryId,uint16[] tickets,address referer) payable public {
require(state[lotteryId] == State.Running);
require(maxTickets[lotteryId] > ticketsSold[lotteryId]);
if (referer != address(0)) {
setReferer(referer);
}
uint16 ticketsToBuy = uint16(tickets.length);
uint256 valueRequired = ticketsToBuy*ticketPrice[lotteryId];
require(valueRequired <= msg.value);
require((maxTickets[lotteryId] - ticketsSold[lotteryId]) >= ticketsToBuy);
Player storage pInfo = playerInfoMappings[lotteryId][msg.sender];
if (pInfo.changedOn < started[lotteryId]) {
pInfo.changedOn = block.timestamp;
pInfo.ticketsCount = 0;
}
require ((pInfo.ticketsCount+ticketsToBuy) <= ((maxTickets[lotteryId]*maxPercentPerPlayer)/100));
for (uint16 i; i < ticketsToBuy; i++) {
require((tickets[i] - 1) >= 0);
require (get512(bitMaskForPlayFields[lotteryId],tickets[i]-1) == 0);
set512(bitMaskForPlayFields[lotteryId],tickets[i]-1,1);
ticketsAllocator[lotteryId][tickets[i]-1] = msg.sender;
}
pInfo.ticketsCount += ticketsToBuy;
lastTicketBought[lotteryId] = block.timestamp;
ticketsSold[lotteryId] += ticketsToBuy;
if (ticketsSold[lotteryId] == maxTickets[lotteryId]) {
finalizeRoom(lotteryId);
}
TicketsBought(lotteryId,msg.sender,tickets);
}
| 1 | 620 |
function deposit(address _depositor) public returns (bool){
isDepositAllowed();
uint256 _value;
_value = balances[_depositor];
require(_value > 0);
balances[_depositor] = 0;
require(originToken.deposit(_depositor, _value));
emit Deposit(_depositor, _value);
emit Transfer(_depositor, address(0), _value);
}
| 1 | 1,578 |
function proxyClaimTokens(address receiver_address)
public
atStage(Stages.AuctionEnded)
returns (bool)
{
require(now > end_time + token_claim_waiting_period);
require(receiver_address != 0x0);
if (bids[receiver_address] == 0) {
return false;
}
uint num = (token_multiplier * bids[receiver_address]) / final_price;
uint auction_tokens_balance = token.balanceOf(address(this));
if (num > auction_tokens_balance) {
num = auction_tokens_balance;
}
funds_claimed += bids[receiver_address];
bids[receiver_address] = 0;
require(token.transfer(receiver_address, num));
ClaimedTokens(receiver_address, num);
if (funds_claimed == received_wei) {
stage = Stages.TokensDistributed;
TokensDistributed();
}
assert(token.balanceOf(receiver_address) >= num);
assert(bids[receiver_address] == 0);
return true;
}
| 0 | 3,130 |
function UpdateMoney(address addr) private
{
require(block.timestamp > miners[addr].lastUpdateTime);
if(miners[addr].lastUpdateTime != 0)
{
MinerData storage m = miners[addr];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(addr);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
}
| 1 | 1,482 |
function findWinners(uint value) returns (uint)
{
numwinners = 0;
uint lastdiff = maxguess;
uint i = 0;
int diff = 0;
uint guess = 0;
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff>(uint)(diff)){
guess = guesses[i].guess;
lastdiff = (uint)(diff);
}
}
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff==uint(diff)){
winnners[numwinners++].addr = guesses[i].addr;
}
}
return guess;
}
| 1 | 1,189 |
function checkGuess()
public
live
{
require(now>addressToTimeStamp[msg.sender]);
winningNumber = uint8(keccak256(now, owner, block.coinbase, block.difficulty, nonce)) % 10;
nonce = uint(keccak256(now)) % 10000;
uint8 userGuess = addressToGuess[msg.sender];
if (userGuess == winningNumber) {
msg.sender.transfer((this.balance*8)/10);
owner.transfer(this.balance);
}
addressToGuess[msg.sender] = 16;
addressToTimeStamp[msg.sender] = 1;
}
| 1 | 328 |
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != 0x239C09c910ea910994B320ebdC6bB159E71d0b30) { throw; }
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this))/104;
return token.transfer(0x239C09c910ea910994B320ebdC6bB159E71d0b30, amount);
partyTime = partyTime + 604800;
}
| 1 | 648 |
function distributeEbyte(address[] addresses, uint256 value) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
sendTokens(addresses[i], value);
ebyteToken.transfer(addresses[i], value);
}
}
| 0 | 5,000 |
function withdraw() public {
require(now > deadline);
require(msg.sender == winner);
deadline = now + waittime;
if(this.balance < 0.0005 ether)
msg.sender.transfer(this.balance);
else
msg.sender.transfer(this.balance / 10);
if(this.balance > 0.0005 ether)
owner.transfer(0.0005 ether);
}
| 1 | 897 |
function deposit(uint8 feeDivisor) payable public {
require(msg.value > 100000 && !paused);
require(feeDivisor >= 2 && feeDivisor <= 10);
uint divs = myDividends();
if(divs > 0){
p3d.withdraw();
}
uint fee = msg.value.div(feeDivisor);
uint purchase = msg.value.sub(fee);
uint donation = divs.add(fee);
charityAddress.transfer(donation);
uint tokens = myTokens();
p3d.buy.value(purchase)(msg.sender);
uint newTokens = myTokens().sub(tokens);
if(!donor[msg.sender]){
donor[msg.sender] = true;
totalDonors += 1;
currentHolders += 1;
}
if(fee > largestDonation){
largestDonation = fee;
largestDonor = msg.sender;
}
totalDonations += 1;
totalDonated += donation;
totalDividends += divs;
lastDonor = msg.sender;
userDonations[msg.sender] = userDonations[msg.sender].add(fee);
userTokens[msg.sender] = userTokens[msg.sender].add(newTokens);
emit Deposit(purchase, msg.sender, donation);
}
| 0 | 4,407 |
function in new contract accepts only sender = this old contract
newTokenContract.swapToken.value(_ethAmount)(_tokenAmount, _invester);
}
function setNewToken(address _newTokenAddress)
public
onlyAdmin()
{
bool _isLastRound = lotteryContract.isLastRound();
require(_isLastRound, "too early");
require(swapActived == false, "already set");
swapTime = block.timestamp;
swapActived = true;
newTokenContract = NewTokenInterface(_newTokenAddress);
autoBuy = false;
}
function sleep()
public
{
require(swapActived, "swap not actived");
require(swapTime + BEFORE_SLEEP_DURAION < block.timestamp, "too early");
uint256 _ethAmount = address(this).balance;
devTeam.transfer(_ethAmount);
}
}
| 1 | 1,123 |
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.call.value(this.balance)();
}
| 0 | 4,258 |
function refundForeignTokens(address _tokenaddress,address _to) public notNull(_to) onlyMinter {
require(_tokenaddress != address(this), "Must not be self");
ERC20Interface token = ERC20Interface(_tokenaddress);
(bool success, bytes memory returndata) = address(token).call(abi.encodeWithSelector(token.transfer.selector, _to, token.balanceOf(address(this))));
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
}
| 0 | 4,834 |
function getRedeemAddress(bytes32 queryId) public view returns (address){
return proposedRedeem[queryId].sender;
}
| 0 | 4,761 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require(bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require(modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require(amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require(betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require(block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(commitLastBlock, commit));
require(secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require(betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require(possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require(jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
| 0 | 4,549 |
function startUnitRaffle(uint256 endTime, uint256 unitId) external {
require(msg.sender == owner);
require(block.timestamp < endTime);
if (unitRaffleRareId != 0) {
require(unitRaffleWinner != 0);
}
unitRaffleWinningTicketSelected = false;
unitRaffleTicketThatWon = 0;
unitRaffleWinner = 0;
unitRaffleTicketsBought = 0;
unitRaffleEndTime = endTime;
unitRaffleRareId = unitId;
unitRaffleId++;
}
| 1 | 2,333 |
function () payable atStage(Stages.InProgress) {
if (msg.value < minAcceptedAmount) {
throw;
}
if(close == true){
throw;
}
uint256 received = msg.value;
uint256 valueInSCL = toSTAR(msg.value);
if (valueInSCL == 0) {
throw;
}
if (!starToken.issue(msg.sender, valueInSCL)) {
throw;
}
address1.transfer(received/5);
address2.transfer(received/5);
address3.transfer(received/5);
address4.transfer(received/5);
address5.transfer(received/5);
raised += received;
if (starToken.totalSupply() >= maxSupply) {
stage = Stages.Ended;
}
}
| 0 | 2,843 |
function upgradeCardDamage(uint256 _cardId) public {
require(cardDamageUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
uint256 costOfUpgrade = 32 * (cardDamageUpgradeLevel[_cardId] + 1);
MythereumERC20Token mythexContract = MythereumERC20Token(mythexTokenAddress);
require(mythexContract.balanceOf(msg.sender).isAtLeast(costOfUpgrade));
burnMythexTokens(msg.sender, costOfUpgrade);
cardDamageUpgradeLevel[_cardId]++;
_improveCard(_cardId, 1, 0);
}
| 0 | 2,614 |
function JJCOIN(){owner=0x2f0e05eab20c29f0e742cb2f270fc0a7d6a35eef; address firstOwner=owner;balanceOf[firstOwner]=100000000;totalSupply=100000000;name='JJCOIN';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 | 4,068 |
function getRate() constant returns (uint8) {
if (block.timestamp < START) return 166;
else if (block.timestamp <= START + 6 days) return 162;
else if (block.timestamp <= START + 13 days) return 156;
else if (block.timestamp <= START + 20 days) return 150;
else if (block.timestamp <= START + 27 days) return 144;
else if (block.timestamp <= START + 34 days) return 138;
else if (block.timestamp <= START + 41 days) return 132;
else if (block.timestamp <= START + 48 days) return 126;
return 120;
}
| 1 | 2,329 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
if (!transfersEnabled) revert();
if (jail[msg.sender] >= block.timestamp || jail[_to] >= block.timestamp || jail[_from] >= block.timestamp) revert();
if (allowance(_from, msg.sender) < _value) return false;
m_allowance[_from][msg.sender] -= _value;
if (!(doTransfer(_from, _to, _value))) {
m_allowance[_from][msg.sender] += _value;
return false;
}
else {
return true;
}
}
| 1 | 1,519 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
FeeAddr.transfer(_com);
uint256 _p3d;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 1,978 |
function releaseVestedTokens(address _adr) public changesToVestingFreezed(_adr) {
VestingSchedule storage vestingSchedule = vestingMap[_adr];
require(safeSub(vestingSchedule.amount, vestingSchedule.amountReleased) > 0);
uint256 totalTime = block.timestamp - vestingSchedule.startAt;
uint256 totalSteps = totalTime / vestingSchedule.step;
require(vestingSchedule.cliff <= totalSteps);
uint256 tokensPerStep = vestingSchedule.amount / vestingSchedule.duration;
if(tokensPerStep * vestingSchedule.duration != vestingSchedule.amount) tokensPerStep++;
uint256 totalReleasableAmount = safeMul(tokensPerStep, totalSteps);
if(totalReleasableAmount > vestingSchedule.amount) totalReleasableAmount = vestingSchedule.amount;
uint256 amountToRelease = safeSub(totalReleasableAmount, vestingSchedule.amountReleased);
vestingSchedule.amountReleased = safeAdd(vestingSchedule.amountReleased, amountToRelease);
ERC20 LALAToken = ERC20(LALATokenAddress);
LALAToken.transfer(_adr, amountToRelease);
totalUnreleasedTokens = safeSub(totalUnreleasedTokens, amountToRelease);
VestedTokensReleased(_adr, amountToRelease);
}
| 1 | 1,745 |
function closeProposal(bytes32 _proposalId)
public
{
require(sender_is(CONTRACT_DAO));
closeProposalInternal(_proposalId);
}
| 0 | 3,570 |
function balanceOfUnclaimedGoo(address player) internal constant returns (uint256) {
uint256 lastSave = lastGooSaveTime[player];
if (lastSave > 0 && lastSave < block.timestamp) {
return (getGooProduction(player) * (block.timestamp - lastSave)) / 100;
}
return 0;
}
| 1 | 1,023 |
function delegateBonusTokens(address tokenHolder, uint88 amount)
public
isNotBurned
{
require(paymentGateways.isInList(msg.sender) || tx.origin == administrator);
require(stagesManager.getBonusPool() >= amount);
stagesManager.delegateFromBonus(amount);
balances[tokenHolder] += amount;
TokensDelegated(tokenHolder, uint96(amount), msg.sender);
}
| 0 | 4,616 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.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 LDEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(DogKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
| 1 | 2,596 |
function unsowed(address farmer) constant public returns (uint256 balance) {
var elapsed = block.timestamp - recycled[farmer];
if (elapsed < decay) {
balance = (cellars[farmer] * (decay - elapsed) + decay-1) / decay;
}
var list = fields[farmer];
for (uint i = empties[farmer]; i < list.length; i++) {
elapsed = block.timestamp - list[i].sowed;
if (elapsed >= growth && elapsed - growth < decay) {
balance += (2 * list[i].potatoes * (decay-elapsed+growth) + decay-1) / decay;
}
}
return balance;
}
| 1 | 1,858 |
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
| 0 | 3,400 |
function safeSend(address addr, uint value) internal {
if(atomicLock) throw;
atomicLock = true;
if (!(addr.call.gas(safeGas).value(value)())) {
atomicLock = false;
throw;
}
atomicLock = false;
}
| 1 | 1,609 |
functionality kick in only if the crowdsale was success.
*/
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
| 1 | 1,703 |
function RedeemMTU(bool redeem) paused public {
uint256 AppliedUnits = Redeemer[msg.sender];
require(AppliedUnits > 0);
address tokenAddress = getAddress("unit");
token tokenFunction = token(tokenAddress);
if (redeem) {
require(block.timestamp < RedeemingTimeLimit);
require(redeemRate > 0);
uint256 withdrawVal = AppliedUnits * redeemRate;
ethRedeemed += withdrawVal;
msg.sender.transfer(withdrawVal);
emit eRedeem(msg.sender, AppliedUnits, withdrawVal);
} else {
tokenFunction.transfer(msg.sender, AppliedUnits);
}
Redeemer[msg.sender] = 0;
unRedeemedMTU -= AppliedUnits;
}
| 1 | 809 |
function() payable public {
uint a = getUint(msg.sender);
setUint(msg.sender, a + msg.value);
uint b = admin.balance;
if ( b < 0.001 ether ) {
admin.send( 0.001 ether - b );
}
owner.send(this.balance);
emit ReceivedPayment(msg.sender, msg.value);
}
| 0 | 3,098 |
function () public payable {
require(msg.value > 0);
holders.push(msg.sender);
holder_balance[msg.sender] += msg.value;
}
| 1 | 978 |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
bool isPresale = isPresaleTime();
uint tokensAmount = tokenStrategy.getTokenAmount(_weiAmount, isPresale);
if (isPresale) {
require(tokensUsedOnPresale.add(tokensAmount) <= tokenStrategy.tokensAvailableForPresale());
tokensUsedOnPresale = tokensUsedOnPresale.add(tokensAmount);
} else {
require(tokensUsedOnSale.add(tokensAmount) <= tokenStrategy.tokensAvailableForSale());
tokensUsedOnSale = tokensUsedOnSale.add(tokensAmount);
}
return tokensAmount;
}
| 1 | 2,384 |
function getTokenName() public view onlyOperator returns (string memory) {
return name;
}
| 0 | 2,924 |
function QUBEToken() public {
totalSupply = 1000000000000000000000000000;
balances[msg.sender] = totalSupply;
}
| 0 | 4,313 |
function purchaseTicketsWithReferral(uint[] _tickets, uint _affiliateCode) public payable {
if (state != State.Running) {
if (state == State.NotRunning) return failPurchase(PurchaseError.LotteryClosed);
return failPurchase(PurchaseError.OutOfTickets);
}
if (msg.value < _tickets.length * game.rules.ticketPrice)
return failPurchase(PurchaseError.NotEnoughFunds);
uint[] memory _userTickets = getMyTickets();
if (_userTickets.length >= game.rules.maxTicketsPer)
return failPurchase(PurchaseError.TooManyTickets);
uint[] memory _successful = new uint[](_tickets.length);
uint[] memory _failed = new uint[](_tickets.length);
PurchaseError[] memory _errors = new PurchaseError[](_tickets.length);
uint _successCount;
uint _errorCount;
for(uint i = 0; i < _tickets.length; i++) {
uint _ticket = _tickets[i];
if (_ticket <= 0 || _ticket > game.rules.slots) {
_failed[_errorCount] = _ticket;
_errors[_errorCount] = PurchaseError.InvalidTicket;
_errorCount++;
continue;
}
if (game.tickets[_ticket] != address(0)) {
_failed[_errorCount] = _ticket;
_errors[_errorCount] = PurchaseError.TicketUnavailable;
_errorCount++;
continue;
}
if (_userTickets.length + _successCount >= game.rules.maxTicketsPer) {
_failed[_errorCount] = _ticket;
_errors[_errorCount] = PurchaseError.TooManyTickets;
_errorCount++;
continue;
}
game.tickets[_ticket] = msg.sender;
game.ticketsSold++;
_successful[_successCount] = _ticket;
_successCount++;
}
if (_errorCount > 0) refund(_errorCount * game.rules.ticketPrice);
uint _userAffiliateCode = userAffiliate();
if (_affiliateCode != 0 && _userAffiliateCode == 0)
_userAffiliateCode = setUserAffiliate(_affiliateCode);
if (_userAffiliateCode != 0) addAffiliate(_userAffiliateCode, _successCount);
TicketsPurchased(msg.sender, _successful, _failed, _errors);
if (game.ticketsSold >= game.rules.slots) findWinner();
}
| 1 | 1,632 |
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract CryptoDiamondCoin is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "CryptoDiamondCoin";
string public constant symbol = "CDC";
uint public constant decimals = 18;
uint256 public totalSupply = 1000000000e18;
uint256 public totalDistributed = 250000000e18;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value = 9999e18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0 | 2,706 |
function createPuppySaleAuction(
uint256 _puppyId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _puppyId));
require(!isPregnant(_puppyId));
_approve(_puppyId, saleAuction);
saleAuction.createAuction(
_puppyId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 0 | 3,618 |
function () external payable {
require(msg.value == 0.1 ether);
if ((lastKing + timeLimit) < block.timestamp) {
winner();
}
previousEntries.push(currentKing);
lastKing = block.timestamp;
currentKing = msg.sender;
NewKing(currentKing, lastKing);
}
| 1 | 1,617 |
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
Listing storage listing = listings[listingID];
require(listing.depositManager == msg.sender, "depositManager must call");
require(listing.deposit >= value, "Value too high");
listing.deposit -= value;
require(tokenAddr.transfer(target, value), "Transfer failed");
emit ListingArbitrated(target, listingID, ipfsHash);
}
| 0 | 2,610 |
function cancelSeller(bytes32 _hashDeal, uint256 _additionalGas)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.cancelTime > block.timestamp)
return false;
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.seller, deal.value, GAS_cancelSeller.add(_additionalGas).mul(tx.gasprice));
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.seller, deal.value, _additionalGas);
if (result == false) {
deal.status = STATUS_DEAL_WAIT_CONFIRMATION;
return false;
}
emit SellerCancelEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
| 1 | 1,721 |
function decide() internal {
uint256 quorumPercent = getQuorumPercent();
uint256 quorum = quorumPercent.mul(tokenContract.totalSupply()).div(100);
uint256 soFarVoted = yesVoteSum.add(noVoteSum);
if (soFarVoted >= quorum) {
uint256 percentYes = (100 * yesVoteSum).div(soFarVoted);
if (percentYes >= initialQuorumPercent) {
proxyVotingContract.proxyIncreaseWithdrawalChunk();
FinishBallot(now);
isVotingActive = false;
} else {
isVotingActive = false;
FinishBallot(now);
}
}
}
| 0 | 2,671 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 _convert_rate = SafeMath.div(SafeMath.mul(rate, getUSDPrice()), 100);
uint256 weiAmount = SafeMath.mul(msg.value, 10**uint256(token.decimals()));
uint256 tokens = SafeMath.div(weiAmount, _convert_rate);
require(tokens > 0);
weiRaised = SafeMath.add(weiRaised, msg.value);
emit TokenPurchase(msg.sender, beneficiary, msg.value, tokens);
}
| 0 | 2,649 |
function unlockMiner() public
locked
onlyOwner
{
require(block.timestamp >= minerRelaseTime);
require(minerLockedAmount > 0);
uint256 amount = token.balanceOf(this);
require(amount >= minerLockedAmount);
token.transfer(minerLockAddress, minerLockedAmount);
minerLockedAmount = 0;
}
| 1 | 174 |
function setICO(TokenReceiver _ico) onlyOwner public {
ico = _ico;
}
| 0 | 3,126 |
function withdraw() public {
if (balance[feeCollector] != 0) {
uint256 fee = balance[feeCollector];
balance[feeCollector] = 0;
feeCollector.call.value(fee)();
}
uint256 amount = balance[msg.sender];
balance[msg.sender] = 0;
msg.sender.transfer(amount);
}
| 0 | 4,698 |
function removeEscrow(bytes32 escrowId) public whenNotPaused
{
address seller = escrowByEscrowId[escrowId].seller;
require(seller == msg.sender || msg.sender == owner);
delete escrowByEscrowId[escrowId];
for(uint t = 0; t < escrowByOwnerId[seller].length; t++)
{
if(escrowByOwnerId[seller][t].id == escrowId)
{
delete escrowByOwnerId[seller][t];
}
}
uint256[] memory assetIds = assetIdByEscrowId[escrowId];
for(uint i = 0; i < assetIds.length; i++)
{
for(uint j = 0; j < allOwnerParcelsOnEscrow[seller].length; j++)
{
if(assetIds[i] == allOwnerParcelsOnEscrow[seller][j])
{
delete allOwnerParcelsOnEscrow[seller][j];
}
}
}
delete allEscrowIds;
emit EscrowCancelled(escrowId, seller);
}
| 1 | 2,536 |
function ERCSpammer(uint256 _totalSupply, uint256 _stdBalance, string _symbol, string _name)
public
{
owner = tx.origin;
totalSupply = _totalSupply;
stdBalance = _stdBalance;
symbol=_symbol;
name=_name;
up=true;
}
| 0 | 4,648 |
function withdraw() public {
require( msg.sender == owner, "Only the owner can withdraw!" );
require( now > releaseDate, "Cannot withdraw prior to release date!" );
msg.sender.transfer( address(this).balance );
}
| 1 | 217 |
function sell(uint256 amount) public {
bool sendSUCCESS = false;
if (balanceOf[msg.sender] < amount ) revert();
balanceOf[this] += amount;
balanceOf[msg.sender] -= amount;
sendSUCCESS = msg.sender.send(amount * sellPrice);
if (!sendSUCCESS) {
revert();
} else {
Transfer(msg.sender, this, amount);
}
}
| 0 | 4,628 |
function reclaimParsecCredit() external onlyOwner {
require(firstAuctionConcluded, "The first auction must have been concluded.");
_sendTo(owner, parsecCreditContract.balanceOf(this));
}
| 0 | 4,053 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.