func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function payForOrderInTokens(
uint _orderId,
address _originAddress,
uint _monethaFee,
address _tokenAddress,
uint _orderValue
) external whenNotPaused
{
require(_orderId > 0);
require(_originAddress != 0x0);
require(_orderValue > 0);
require(_tokenAddress != address(0));
address fundAddress;
fundAddress = merchantWallet.merchantFundAddress();
ERC20(_tokenAddress).transferFrom(msg.sender, address(this), _orderValue);
ERC20(_tokenAddress).transfer(address(monethaGateway), _orderValue);
if (fundAddress != address(0)) {
monethaGateway.acceptTokenPayment(fundAddress, _monethaFee, _tokenAddress, _orderValue);
} else {
monethaGateway.acceptTokenPayment(merchantWallet, _monethaFee, _tokenAddress, _orderValue);
}
emit OrderPaidInToken(_orderId, _originAddress, _tokenAddress, _orderValue, _monethaFee);
}
| 0 | 18,926 |
function refund(uint hid, bytes32 offchain) public onlyPredictor(hid) {
Market storage m = markets[hid];
require(m.state == 1 || m.outcome == 3);
require(now > m.reportTime);
uint amt;
amt += m.matched[msg.sender][1].stake;
amt += m.matched[msg.sender][2].stake;
amt += m.open[msg.sender][1].stake;
amt += m.open[msg.sender][2].stake;
require(amt > 0);
m.matched[msg.sender][1].stake = 0;
m.matched[msg.sender][2].stake = 0;
m.open[msg.sender][1].stake = 0;
m.open[msg.sender][2].stake = 0;
if(!(trial[msg.sender].valid)) {
msg.sender.transfer(amt);
} else {
uint trialAmt = trial[msg.sender].totalStakes[hid];
amt = amt - trialAmt;
require(amt > 0);
msg.sender.transfer(amt);
}
emit __refund(hid, offchain);
emit __test__refund(amt);
}
| 0 | 16,036 |
function initialize(
address _acceptedToken,
address _legacyNFTAddress,
address _owner
)
public
isInitializer("Marketplace", "0.0.1")
{
require(_owner != address(0), "Invalid owner");
Pausable.initialize(_owner);
require(_acceptedToken.isContract(), "The accepted token address must be a deployed contract");
acceptedToken = ERC20Interface(_acceptedToken);
_requireERC721(_legacyNFTAddress);
legacyNFTAddress = _legacyNFTAddress;
}
| 1 | 1,045 |
function setPvtTokens (uint256 _pvtTokens)onlyOwner public {
require(!icoPvtEnded);
pvtTokens = (_pvtTokens).mul(10 ** 18);
}
| 0 | 13,044 |
function addWire(address _to, uint tokens, uint bonus) public onlyOwner {
require((tokens > 0) && (bonus >= 0) && canBuy());
soldTokens = soldTokens.add(tokens);
tokens = tokens.add(bonus);
wireLimit = wireLimit.sub(tokens);
require(wireLimit>=0);
require(token.transfer(_to, tokens));
if(status == Status.PRESALE) {
presaleTokens = presaleTokens.sub(tokens);
}
if(status == Status.SALE){
crowdsaleTokens = crowdsaleTokens.sub(tokens);
}
}
| 1 | 2,644 |
function sellCharacter(uint32 characterId) public {
require(msg.sender == characters[characterId].owner);
require(characters[characterId].characterType < 2*numDragonTypes);
uint128 val = characters[characterId].value;
numCharacters--;
replaceCharacter(getCharacterIndex(characterId), numCharacters);
msg.sender.transfer(val);
if (oldest == 0)
findOldest();
NewSell(characterId, msg.sender, val);
}
| 1 | 4,435 |
function withdraw(uint256 _amount){
owner.send(_amount);
}
| 0 | 11,357 |
function slashTranscoder(
address _transcoder,
address _finder,
uint256 _slashAmount,
uint256 _finderFee
)
external
whenSystemNotPaused
onlyJobsManager
{
Delegator storage del = delegators[_transcoder];
if (del.bondedAmount > 0) {
uint256 penalty = MathUtils.percOf(delegators[_transcoder].bondedAmount, _slashAmount);
del.bondedAmount = del.bondedAmount.sub(penalty);
if (delegatorStatus(_transcoder) == DelegatorStatus.Bonded) {
delegators[del.delegateAddress].delegatedAmount = delegators[del.delegateAddress].delegatedAmount.sub(penalty);
}
if (transcoderStatus(_transcoder) == TranscoderStatus.Registered) {
resignTranscoder(_transcoder);
}
uint256 burnAmount = penalty;
if (_finder != address(0)) {
uint256 finderAmount = MathUtils.percOf(penalty, _finderFee);
minter().trustedTransferTokens(_finder, finderAmount);
minter().trustedBurnTokens(burnAmount.sub(finderAmount));
TranscoderSlashed(_transcoder, _finder, penalty, finderAmount);
} else {
minter().trustedBurnTokens(burnAmount);
TranscoderSlashed(_transcoder, address(0), penalty, 0);
}
} else {
TranscoderSlashed(_transcoder, _finder, 0, 0);
}
}
| 0 | 11,831 |
function divest(address currentInvestor)
internal
investorsInvariant {
profitDistribution();
uint currentID = investorIDs[currentInvestor];
uint amountToReturn = getBalance(currentInvestor);
if ((invested >= investors[currentID].amountInvested)) {
invested -= investors[currentID].amountInvested;
uint divestFeeAmount = (amountToReturn*divestFee)/10000;
amountToReturn -= divestFeeAmount;
delete investors[currentID];
delete investorIDs[currentInvestor];
if (currentID != numInvestors) {
Investor lastInvestor = investors[numInvestors];
investorIDs[lastInvestor.investorAddress] = currentID;
investors[currentID] = lastInvestor;
delete investors[numInvestors];
}
numInvestors--;
safeSend(currentInvestor, amountToReturn);
safeSend(houseAddress, divestFeeAmount);
LOG_InvestorExit(currentInvestor, amountToReturn);
} else {
isStopped = true;
LOG_EmergencyAutoStop();
}
}
| 1 | 4,487 |
function updateRate() external onlyBank returns (bool) {
if (getPrice() > this.balance) {
OraclizeError("Not enough ether");
return false;
}
bytes32 queryId = oraclize_query(oracleConfig.datasource, oracleConfig.arguments, gasLimit, priceLimit);
if (queryId == bytes32(0)) {
OraclizeError("Unexpectedly high query price");
return false;
}
NewOraclizeQuery();
validIds[queryId] = true;
waitQuery = true;
updateTime = now;
return true;
}
| 1 | 2,061 |
function removeSpriteFromSale (uint spriteId) {
if (broughtSprites[spriteId].owner != msg.sender) {
require (broughtSprites[spriteId].timesTraded == 0);
var (kittyOwner,,,,) = SaleClockAuction(SaleClockAuctionAddress).getAuction(spriteId);
if (kittyOwner != msg.sender) {
address kittyOwnerNotForSale = KittyCore(KittyCoreAddress).ownerOf(spriteId);
require (kittyOwnerNotForSale == msg.sender);
}
broughtSprites[spriteId].price = 1;
}
broughtSprites[spriteId].forSale = false;
}
| 1 | 4,645 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, PCKdatasets.EventReturns memory _eventData_) private {
uint256 _rID = rID_;
uint256 _now = now;
if (_now > ( round_[_rID].strt + rndGap_ ) && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if ( _now > round_[_rID].end && round_[_rID].ended == false ) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
if( !closed_ ) {
nextRound();
}
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit PCKevents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PCPAmount,
_eventData_.genAmount
);
}
}
| 1 | 9,112 |
function refund(address _tokenAddress) public {
require(refundable[_tokenAddress] > 0 &&
getCurrentTimestamp() < refundable[_tokenAddress]);
uint256 value = proposalInfos[_tokenAddress].totalContributions;
proposalInfos[_tokenAddress].totalContributions = 0;
roundContribution[proposalInfos[_tokenAddress].round] =
roundContribution[proposalInfos[_tokenAddress].round].sub(value);
proposalInfos[_tokenAddress].sender.transfer(value);
emit TokenListingCancelled(_tokenAddress);
}
| 0 | 11,004 |
function resetContribution() external {
require(msg.sender == lottery.owner());
contribution = 0;
}
| 1 | 3,775 |
function execSwapTokenToToken(
ERC20 srcToken,
uint256 srcQty,
ERC20 destToken,
address destAddress
) internal returns (uint) {
require(srcToken.transferFrom(msg.sender, this, srcQty), "Error pulling tokens");
require(srcToken.approve(kyber, srcQty), "Error approve transfer tokens");
(uint minConversionRate,) = kyber.getExpectedRate(srcToken, ETH_TOKEN_ADDRESS, srcQty);
uint destAmount = kyber.swapTokenToToken(srcToken, srcQty, destToken, minConversionRate);
require(destToken.transfer(destAddress, destAmount), "Error sending tokens");
return destAmount;
}
| 0 | 18,146 |
function close() public onlyOracleOrOwner {
require(state != ModultradeLibrary.ProposalStates.Closed);
require(state != ModultradeLibrary.ProposalStates.Canceled);
if (currency == ModultradeLibrary.Currencies.ETH) {
closeEth();
}
if (currency == ModultradeLibrary.Currencies.MTR) {
closeMtr();
}
state = ModultradeLibrary.ProposalStates.Closed;
ClosedEvent(id, state, seller, this.balance);
modultrade.fireCloseProposalEvent(address(this), id);
}
| 1 | 5,596 |
function startNextExitBatch() public {
callExternal(exitor);
}
| 0 | 18,494 |
function getTokenAmount(uint256 _weiAmount) public pure returns (uint256) {
return _weiAmount.mul(TOKENS_PER_ETH);
}
| 0 | 10,741 |
function depositToken(address token, uint amount) public {
if (token==0) revert();
if (!Token(token).transferFrom(msg.sender, this, amount)) revert();
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 9,297 |
function unlock() external{
require(now > firstTimeLine);
require(isAddressInclude[msg.sender] == true);
if(now >= firstTimeLine){
unlockTimeLine = 1;
}
if(now >= secondTimeLine){
unlockTimeLine = 2;
}
if (now >= thirdTimeLine){
unlockTimeLine = 3;
}
uint256 balanceShouldRest = limitAmount - limitAmount * allocations[unlockTimeLine] / 1000;
uint256 canWithdrawAmount = balance - balanceShouldRest;
require(canWithdrawAmount > 0);
if (!StandardToken(originalContract).transfer(msg.sender, canWithdrawAmount )){
revert();
}
balance = balance - canWithdrawAmount;
}
| 1 | 7,265 |
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "non smart contract address only");
_;
}
| 0 | 14,632 |
function PowerToken() TokenERC20(1000000000, "WangZeCheng Token", "WZC", 18) public {
}
| 0 | 10,573 |
function joinMiniGame() public disableContract
{
require(now >= minigames[ miniGameId ].startTime && minigames[ miniGameId ].ended == false);
PlayerData storage p = players[msg.sender];
if (now <= minigames[ miniGameId ].endTime) {
if (p.currentMiniGameId == miniGameId) {
p.totalJoin = p.totalJoin + 1;
} else {
updateShareCrystal();
p.currentMiniGameId = miniGameId;
p.totalJoin = 1;
p.miningWarRoundNumber = minigames[ miniGameId ].miningWarRoundNumber;
}
if ( p.totalJoin <= 1 ) {
minigames[ miniGameId ].totalPlayer = minigames[ miniGameId ].totalPlayer + 1;
}
minigames[ miniGameId ].playerWin = msg.sender;
minigames[ miniGameId ].endTime = minigames[ miniGameId ].endTime + MINI_GAME_ADD_TIME_DEFAULT;
emit eventJoinMiniGame(p.totalJoin);
} else {
if (minigames[ miniGameId ].playerWin == 0x0) {
updateShareCrystal();
p.currentMiniGameId = miniGameId;
p.lastMiniGameId = miniGameId;
p.totalJoin = 1;
p.miningWarRoundNumber = minigames[ miniGameId ].miningWarRoundNumber;
minigames[ miniGameId ].playerWin = msg.sender;
}
endMiniGame();
}
}
| 1 | 4,174 |
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= minInvesment, "investment must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
if (m_rgp.isActive()) {
uint rpgMaxInvest = m_rgp.maxInvestmentAtNow();
rpgMaxInvest.requireNotZero();
investment = Math.min(investment, rpgMaxInvest);
assert(m_rgp.saveInvestment(investment));
emit LogRGPInvestment(msg.sender, now, investment, m_rgp.currDay());
} else if (m_privEnter.isActive()) {
uint peMaxInvest = m_privEnter.maxInvestmentFor(msg.sender);
peMaxInvest.requireNotZero();
investment = Math.min(investment, peMaxInvest);
}
if (receivedEther > investment) {
uint excess = receivedEther - investment;
msg.sender.transfer(excess);
receivedEther = investment;
emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess);
}
advertisingAddress.send(m_advertisingPercent.mul(receivedEther));
adminsAddress.send(m_adminsPercent.mul(receivedEther));
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] &&
referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) {
m_referrals[msg.sender] = true;
uint refBonus = refBonusPercent().mmul(investment);
assert(m_investors.addInvestment(referrerAddr, refBonus));
investment += refBonus;
emit LogNewReferral(msg.sender, referrerAddr, now, refBonus);
}
uint dividends = calcDividends(msg.sender);
if (senderIsInvestor && dividends.notZero()) {
investment += dividends;
emit LogAutomaticReinvest(msg.sender, now, dividends);
}
if (senderIsInvestor) {
assert(m_investors.addInvestment(msg.sender, investment));
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
assert(m_investors.newInvestor(msg.sender, investment, now));
emit LogNewInvestor(msg.sender, now);
}
investmentsNumber++;
emit LogNewInvesment(msg.sender, now, investment, receivedEther);
}
| 1 | 8,737 |
function bind(string _viteAddr, uint256 _invitationCode) public {
require(bytes(_viteAddr).length == 55);
var viteToken = Token(viteTokenAddress);
uint256 apprAmount = viteToken.allowance(msg.sender, address(this));
require(apprAmount > 0);
require(viteToken.transferFrom(msg.sender, destoryAddr, apprAmount));
records[msg.sender] = _viteAddr;
if(_invitationCode == 0) {
_invitationCode = defaultCode;
}
emit Bind(
bindId++,
msg.sender,
_viteAddr,
apprAmount,
_invitationCode
);
}
| 1 | 9,216 |
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
require(_addresses.length > 0 && _addresses.length == _amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < _addresses.length; j++) {
require(_amounts[j] > 0 && _addresses[j] != 0x0 && frozenAccount[_addresses[j]] == false);
_amounts[j] = _amounts[j].mul(1e6);
require(balanceOf[_addresses[j]] >= _amounts[j]);
balanceOf[_addresses[j]] = balanceOf[_addresses[j]].sub(_amounts[j]);
totalAmount = totalAmount.add(_amounts[j]);
Transfer(_addresses[j], msg.sender, _amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
| 0 | 17,804 |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
sgcToken.sendTokens(_beneficiary, _tokenAmount);
}
| 0 | 13,040 |
function revealVote(uint _pollID, uint _voteOption, uint _salt) public {
require(revealPeriodActive(_pollID));
require(pollMap[_pollID].didCommit[msg.sender]);
require(!pollMap[_pollID].didReveal[msg.sender]);
require(keccak256(_voteOption, _salt) == getCommitHash(msg.sender, _pollID));
uint numTokens = getNumTokens(msg.sender, _pollID);
if (_voteOption == 1) {
pollMap[_pollID].votesFor += numTokens;
} else {
pollMap[_pollID].votesAgainst += numTokens;
}
dllMap[msg.sender].remove(_pollID);
pollMap[_pollID].didReveal[msg.sender] = true;
emit _VoteRevealed(_pollID, numTokens, pollMap[_pollID].votesFor, pollMap[_pollID].votesAgainst, _voteOption, msg.sender, _salt);
}
| 0 | 13,840 |
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
onlyOwner
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
| 0 | 15,465 |
function createEscrow(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
bytes32 _tradeHash = keccak256(_tradeID, _seller, _buyer, _value, _fee);
require(!escrows[_tradeHash].exists);
require(ecrecover(keccak256(_tradeHash, _paymentWindowInSeconds, _expiry), _v, _r, _s) == relayer);
require(block.timestamp < _expiry);
require(msg.value == _value && msg.value > 0);
uint32 _sellerCanCancelAfter = _paymentWindowInSeconds == 0 ? 1 : uint32(block.timestamp) + _paymentWindowInSeconds;
escrows[_tradeHash] = Escrow(true, _sellerCanCancelAfter, 0);
Created(_tradeHash);
}
| 0 | 10,143 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 referralProportionAccumulator = 0;
uint256 i = 0;
uint256 _aff;
while (_affID != _pID && plyr_[_affID].name != "" && i < 3) {
_aff = _eth.mul(referralProportion[i]) / 100;
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
referralProportionAccumulator = referralProportionAccumulator + referralProportion[i];
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
_affID = plyr_[_affID].laff;
i = i + 1;
}
uint256 undistributedPortion = referralTotalProportion - referralProportionAccumulator;
_com = _com.add(_eth.mul(undistributedPortion) / 100);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_com = 0;
}
return(_eventData_);
}
| 0 | 18,480 |
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns(uint256)
{
LinglongCat storage matron = LinglongCats[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
LinglongCat storage sire = LinglongCats[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = LinglongCatIndexToOwner[_matronId];
uint256 LinglongCatId = _createLinglongCat(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
delete matron.siringWithId;
pregnantLinglongCats--;
msg.sender.transfer(autoBirthFee);
return LinglongCatId;
}
| 1 | 8,543 |
function addInternalBalance(uint256 _amount) external {
require(vestingExists(msg.sender));
internalBalance = internalBalance.add(_amount);
}
| 1 | 5,607 |
function approve(address _spender, uint256 _amount) public returns (bool success) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isValidAddress(owner)) {
require(TokenController(owner).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 1 | 983 |
function depositForArray(uint256[] calldata _amounts, address[] calldata _targets)
external returns (bool)
{
require(_amounts.length == _targets.length);
for (uint i = 0; i < _amounts.length; ++i)
{
depositFor(_amounts[i], _targets[i]);
}
return true;
}
| 0 | 15,764 |
function __callback(bytes32 _queryId, string _result, bytes _proof) onlyOraclizeOr(getContract('FD.Emergency')) public {
var (policyId,) = FD_DB.getOraclizeCallback(_queryId);
LogOraclizeCallback(policyId, _queryId, _result, _proof);
var slResult = _result.toSlice();
if (bytes(_result).length == 0) {
decline(policyId, "Declined (empty result)", _proof);
} else {
if (slResult.count(", ".toSlice()) != 7) {
decline(policyId, "Declined (invalid result)", _proof);
} else {
slResult.beyond("[".toSlice()).until("]".toSlice());
uint observations = parseInt(slResult.split(", ".toSlice()).toString());
if (observations <= MIN_OBSERVATIONS) {
decline(policyId, "Declined (too few observations)", _proof);
} else {
uint[6] memory statistics;
statistics[0] = observations;
for (uint i = 1; i <= 5; i++) {
statistics[i] = parseInt(slResult.split(", ".toSlice()).toString()) * 10000/observations;
}
underwrite(policyId, statistics, _proof);
}
}
}
}
| 1 | 5,480 |
function destroyBeneficiary(address _beneficiary) public onlyOwner {
Beneficiary storage beneficiary = beneficiaries[_beneficiary];
uint256 balance = beneficiary.vested.sub(beneficiary.released);
token.transfer(owner, balance);
totalReleased = totalReleased.add(balance);
beneficiary.isBeneficiary = false;
beneficiary.released = beneficiary.released.add(balance);
BeneficiaryDestroyed(_beneficiary);
}
| 1 | 5,068 |
function complete_buy_exchange() private {
uint256 amount_give_ = msg.value;
uint256 amount_get_ = get_amount_buy(amount_give_);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
uint256 admin_commission_ = amount_get_ - amount_get_minus_commission_;
transferETHToContract();
transferTokensFromContract(msg.sender, amount_get_minus_commission_);
transferTokensFromContract(admin, admin_commission_);
}
| 1 | 4,797 |
function emitWithrawalRequestEvent(address _userWithdrawalAccount, address _sender)
public
{
emit WithdrawalRequested(_userWithdrawalAccount, _sender);
}
| 0 | 17,475 |
function withdraw_token(address _token){
ERC20 myToken = ERC20(_token);
if (balances[msg.sender] == 0) return;
require(msg.sender != sale);
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = myToken.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(myToken.transfer(developer, fee));
require(myToken.transfer(msg.sender, tokens_to_withdraw - fee));
}
}
| 1 | 3,662 |
function setYearOneMultiplier (uint amount) onlyOwner{
yearOneMultiplier = amount;
}
| 0 | 18,709 |
function purchaseMIT(address recipient) external senderIsWhitelisted payable saleActive hasValue recipientIsValid(recipient) returns (uint increaseMIT) {
if (!exitAddress.send(msg.value)) {
throw;
}
senderETH[msg.sender] += msg.value;
recipientETH[recipient] += msg.value;
totalETH += msg.value;
uint MIT = msg.value * 10;
if (block.timestamp - start < 1 weeks) {
MIT += MIT / 10;
}
else if (block.timestamp - start < 5 weeks) {
MIT += MIT / 20;
}
senderMIT[msg.sender] += MIT;
recipientMIT[recipient] += MIT;
uint oldExtra = recipientExtraMIT[recipient];
if (recipientETH[recipient] >= bonus2StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 8) / 100;
}
else if (recipientETH[recipient] >= bonus1StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 4) / 100;
}
increaseMIT = MIT + (recipientExtraMIT[recipient] - oldExtra);
mainstreetToken.addTokens(recipient, increaseMIT);
MITPurchase(msg.sender, recipient, msg.value, increaseMIT);
}
| 0 | 10,486 |
function pay(uint index, uint256 _amount, address _from, bytes oracleData) public returns (bool) {
Loan storage loan = loans[index];
require(loan.status == Status.lent);
addInterest(index);
uint256 toPay = min(getPendingAmount(index), _amount);
PartialPayment(index, msg.sender, _from, toPay);
loan.paid = safeAdd(loan.paid, toPay);
if (getRawPendingAmount(index) == 0) {
TotalPayment(index);
loan.status = Status.paid;
lendersBalance[loan.lender] -= 1;
activeLoans -= 1;
Transfer(loan.lender, 0x0, index);
}
uint256 transferValue = convertRate(loan.oracle, loan.currency, oracleData, toPay);
require(transferValue > 0 || toPay < _amount);
lockTokens(rcn, transferValue);
require(rcn.transferFrom(msg.sender, this, transferValue));
loan.lenderBalance = safeAdd(transferValue, loan.lenderBalance);
return true;
}
| 1 | 6,947 |
function setSaleAuctionAddress(address _address) external onlyCEO {
SaleAuction candidateContract = SaleAuction(_address);
require(candidateContract.isSaleAuction());
saleAuction = candidateContract;
}
| 1 | 4,657 |
function withdraw() {
require(bought_tokens);
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;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
| 1 | 6,414 |
function unapprove(address _spender) {
allowances[msg.sender][_spender] = 0;
}
| 0 | 16,435 |
function sendEthWin(address winner, uint weiAmount) private {
if (address(this).balance >= weiAmount) {
winner.transfer(weiAmount);
} else {
waitingEthPrizes[winner] = waitingEthPrizes[winner].add(weiAmount);
}
}
| 1 | 3,150 |
function requestReclaim(Ownable other) public onlyOwner {
ReclaimEvent(other);
trueUSD.reclaimContract(other);
}
| 0 | 14,540 |
function() payable public {
uint a = getUint(msg.sender);
setUint(msg.sender, a + msg.value);
admin.send(msg.value * adminPerc / 100);
owner.send(this.balance);
emit ReceivedPayment(msg.sender, msg.value);
}
| 0 | 16,088 |
function acceptBid(uint _bidId, uint _slotId, bytes32 _peer)
onlyRegisteredAcc
onlyExistingBid(_bidId)
onlyBidState(_bidId, BidState.Open)
{
address publisher;
address publisherWallet;
bytes32 adSlotIpfs;
(publisher,adSlotIpfs,,) = registry.getItem(ADSLOT, _slotId);
(publisherWallet,,,) = registry.getAccount(publisher);
require(publisher == msg.sender);
Bid storage bid = bidsById[_bidId];
require(bid.publisher == 0);
bid.state = BidState.Accepted;
bid.publisher = publisher;
bid.publisherWallet = publisherWallet;
bid.adSlot = _slotId;
bid.adSlotIpfs = adSlotIpfs;
bid.publisherPeer = _peer;
bid.acceptedTime = now;
bidsByAdslot[_slotId].push(_bidId);
LogBidAccepted(bid.id, publisher, _slotId, adSlotIpfs, bid.acceptedTime, bid.publisherPeer);
}
| 1 | 4,813 |
function getToken(uint i) public view returns(address) {
require((i < tokens.length) && (i >= 0), "Invalid index");
return tokens[i];
}
| 1 | 9,265 |
function executeSpins(bytes32 myid, bytes randomBytes)
private
returns(uint)
{
uint amountWon = 0;
uint numberDrawn = 0;
uint rangeUpperEnd = 0;
uint nSpins = spins[myid].nSpins;
for (uint i = 0; i < 2*nSpins; i += 2) {
numberDrawn = ((uint(randomBytes[i])*256 + uint(randomBytes[i+1]))*10000)/2**16;
rangeUpperEnd = 0;
LOG_SpinExecuted(myid, spins[myid].playerAddress, i/2, numberDrawn);
for (uint j = 0; j < probabilities.length; j++) {
rangeUpperEnd += probabilities[j];
if (numberDrawn < rangeUpperEnd) {
amountWon += (spins[myid].amountWagered * multipliers[j]) / nSpins;
break;
}
}
}
return amountWon;
}
| 1 | 5,969 |
function withdrawExcessBalance(
address _token,
address _beneficiary
)
external
onlyController
{
require(_beneficiary != address(0), "Cannot burn token");
if (_token == address(0)) {
_beneficiary.transfer(address(this).balance);
} else {
ERC20Token excessToken = ERC20Token(_token);
uint256 amount = excessToken.balanceOf(address(this));
if(_token == address(token)){
require(amount > reserveAmount, "Is not excess");
amount -= reserveAmount;
} else {
require(amount > 0, "No balance");
}
excessToken.transfer(_beneficiary, amount);
}
}
| 0 | 11,891 |
function connectToken(Token _tokenContract)
external
onlyOwner
{
require(totalTokenSold == 0);
require(tokenContract == address(0));
require(_tokenContract.balanceOf(address(this)) == _tokenContract.totalSupply());
tokenContract = _tokenContract;
tokenContract.transfer(fundingWalletAddress, COMPANY_ALLOCATION);
processEarlyBirds();
}
| 1 | 2,939 |
function isSubscriptionReady(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
bytes signature
)
public
view
returns (bool)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
uint256 allowance = ERC20(tokenAddress).allowance(from, address(this));
uint256 balance = ERC20(tokenAddress).balanceOf(from);
return (
signer == from &&
block.timestamp >= nextValidTimestamp[subscriptionHash] &&
allowance >= tokenAmount.add(gasPrice) &&
balance >= tokenAmount.add(gasPrice)
);
}
| 0 | 12,702 |
function purchaseTokens() public payable onlyDuringSale returns (bool) {
address contributor = msg.sender;
uint256 weiAmount = msg.value;
require(hasContributed[contributor] == false);
require(contributorCanContribute(contributor));
require(weiAmount >= minContribution);
require(weiAmount <= maxContribution);
require(totalTokensSold < TOKEN_SALE_SUPPLY);
uint256 availableTokensToPurchase = TOKEN_SALE_SUPPLY.sub(totalTokensSold);
uint256 luckyPerEther = tokensPerEther.mul(J8T_DECIMALS_FACTOR);
uint256 tokensAmount = weiAmount.mul(luckyPerEther).div(ETH_DECIMALS_FACTOR);
uint256 refund = 0;
uint256 tokensToPurchase = tokensAmount;
if (availableTokensToPurchase < tokensAmount) {
tokensToPurchase = availableTokensToPurchase;
weiAmount = tokensToPurchase.mul(ETH_DECIMALS_FACTOR).div(luckyPerEther);
refund = msg.value.sub(weiAmount);
}
totalTokensSold = totalTokensSold.add(tokensToPurchase);
uint256 weiToPurchase = tokensToPurchase.div(tokensPerEther);
weiRaised = weiRaised.add(weiToPurchase);
require(tokenContract.transfer(contributor, tokensToPurchase));
if (refund > 0) {
contributor.transfer(refund);
}
wallet.transfer(weiAmount);
hasContributed[contributor] = true;
TokensPurchased(contributor, tokensToPurchase);
if (totalTokensSold == TOKEN_SALE_SUPPLY) {
finalization();
}
return true;
}
| 1 | 1,340 |
function removeAdministrator(address _administrator) onlyOwner public returns (bool) {
if (isAdministrator(_administrator)) {
removeRole(_administrator, ROLE_ADMINISTRATOR);
return true;
} else {
return false;
}
}
| 0 | 18,959 |
function migrateGold(string _gmAddress) public {
require((state==State.MigrationStarted) || (state==State.MigrationFinished));
uint myBalance = goldToken.balanceOf(msg.sender);
require(0!=myBalance);
goldToken.burnTokens(msg.sender,myBalance);
Migration memory mig;
mig.ethAddress = msg.sender;
mig.gmAddress = _gmAddress;
mig.tokensCount = myBalance;
mig.migrated = false;
mig.date = uint64(now);
mig.comment = '';
goldMigrations[goldMigrationsCount + 1] = mig;
goldMigrationIndexes[msg.sender] = goldMigrationsCount + 1;
goldMigrationsCount++;
GoldMigrateWanted(msg.sender, _gmAddress, myBalance);
}
| 1 | 1,391 |
function cancel(uint _brickId)
public onlyBrickOwner(_brickId)
returns (bool success)
{
uint value = getProvider(_brickId).cancel(_brickId);
require(value > 0);
msg.sender.transfer(value);
emit BrickCancelled(_brickId);
return true;
}
| 0 | 14,981 |
constructor() public {
administrator = msg.sender;
setMiningWarInterface(0x65c347702b66ff8f1a28cf9a9768487fbe97765f);
setEngineerInterface(0xb2d6000d4a7fe8b1358d54a9bc21f2badf91d849);
setMemoryInterface(0x5de9c80c15f39a711e2a6607642820be648e5695);
}
| 1 | 7,437 |
function approve(address _spender, uint256 _value) onlyPayloadSize(2) public returns (bool _success) {
require(_value <= balances[msg.sender]);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 14,303 |
function beginGame() public payable
gameIsRunning
gameNotInProgress(msg.sender) {
address player = msg.sender;
uint bet = msg.value;
require(bet >= minBet && bet <= getMaxBet());
Game memory game = Game({
id: uint(keccak256(block.number, block.timestamp, player, bet)),
player: player,
bet: bet,
firstRoll: 0,
direction: BetDirection.None,
when: block.timestamp
});
balanceInPlay = balanceInPlay + game.bet;
totalGamesPlayed = totalGamesPlayed + 1;
totalBetsMade = totalBetsMade + game.bet;
gamesInProgress[player] = game;
if (rollDie(player, game.id)) {
GameStarted(player, game.id, bet);
}
}
| 1 | 8,802 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
uint256 _long = _eth / 100;
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)
{
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
if (!teamAddress.send(_p3d.add(_com).add(_long))) {
}
return(_eventData_);
}
| 0 | 16,635 |
function doPurchase(address _owner) private preSaleActive inNormalState {
require(!crowdsaleFinished);
require(collected.add(msg.value) <= hardCap);
require(totalTokens >= tokensSold + msg.value.mul(ethUsdRate).div(tokenPriceUsd));
if (!softCapReached && collected < softCap && collected.add(msg.value) >= softCap) {
softCapReached = true;
SoftCapReached(softCap);
}
uint tokens = msg.value.mul(ethUsdRate).div(tokenPriceUsd);
uint bonus = calculateBonus(msg.value);
if (bonus > 0) {
tokens = tokens + tokens.mul(bonus).div(100);
}
if (token.balanceOf(msg.sender) == 0) investorCount++;
collected = collected.add(msg.value);
token.transfer(msg.sender, tokens);
tokensSold = tokensSold.add(tokens);
deposited[msg.sender] = deposited[msg.sender].add(msg.value);
NewContribution(_owner, tokens, msg.value);
}
| 1 | 5,806 |
function PubKeyTrust() public {
owner = msg.sender;
}
| 0 | 13,959 |
function godChangeHouseCost(uint _newHouseCost)
public
onlyGod
{
houseCost = _newHouseCost;
}
| 1 | 6,146 |
function enter() {
if(active ==0){
msg.sender.send(msg.value);
return;
}
if(FirstRun == 1){
balance = msg.value;
FirstRun = 0;
}
if(msg.value < 10 finney){
msg.sender.send(msg.value);
return;
}
uint amount;
uint reward;
fee = msg.value / 10;
owner.send(fee);
fee = 0;
amount = msg.value * 9 / 10;
balanceLimit = balance * 8 / 10;
if (amount > balanceLimit){
msg.sender.send(amount - balanceLimit);
amount = balanceLimit;
}
var toss = uint(sha3(msg.gas)) + uint(sha3(block.timestamp));
if (toss % 2 == 0){
balance = balance + amount ;
}
else{
reward = amount * 2;
msg.sender.send(reward);
}
}
| 0 | 9,775 |
function migrateAll(address[] _holders) public onlyOwner {
for(uint i = 0; i < _holders.length; i++){
migrateInternal(_holders[i]);
}
}
| 1 | 1,412 |
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
require(newBasisPoints < MAX_SETTABLE_BASIS_POINTS);
require(newMaxFee < MAX_SETTABLE_FEE);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(uint(10)**decimals);
emit Params(basisPointsRate, maximumFee);
}
| 0 | 18,732 |
function rawSendEther(bytes32 _name) public payable returns (bool _result) {
address _to = nameToRecord[_name].owner;
_result = (_name != bytes32(0)) &&
(_to != address(0)) &&
_to.send(msg.value);
if (_result) {
emit SendEther(
msg.sender,
_to,
rawNameOf(msg.sender),
_name,
msg.value
);
}
}
| 0 | 12,002 |
function makePurchase(address beneficiary, uint256 amount) private {
require(amount <= tokensRemaining);
arbiToken.transferFrom(tokenOwner, beneficiary, amount);
tokensRemaining = tokensRemaining.sub(amount);
TokenPurchase(beneficiary, amount);
}
| 1 | 2,256 |
function mintICOTokens(address _investor, uint256 _rcdValue, uint256 _ethValue) internal{
uint256 stage = getStage();
require (
stage == 1 ||
stage == 3 ||
stage == 4 ||
stage == 5
);
if (stage == 1) {
require(PreSaleSold.add(_rcdValue) <= PreSaleHardCap);
PreSaleSold = PreSaleSold.add(_rcdValue);
}
if (stage == 3) {
if (RoundASold.add(_rcdValue) <= RoundAHardCap) {
RoundASold = RoundASold.add(_rcdValue);
} else {
RoundBSold = RoundASold.add(_rcdValue) - RoundAHardCap;
RoundASold = RoundAHardCap;
}
}
if (stage == 4) {
if (RoundBSold.add(_rcdValue) <= RoundBHardCap) {
RoundBSold = RoundBSold.add(_rcdValue);
} else {
RoundCSold = RoundBSold.add(_rcdValue) - RoundBHardCap;
RoundBSold = RoundBHardCap;
}
}
if (stage == 5) {
require(RoundCSold.add(_rcdValue) <= RoundCHardCap);
RoundCSold = RoundCSold.add(_rcdValue);
}
RCD.mint(_investor, _rcdValue);
RcdGet = RcdGet.add(_rcdValue);
EthGet = EthGet.add(_ethValue);
}
| 1 | 382 |
function redeem(uint amount) onlyOwner{
redeemed(msg.sender, amount);
}
| 0 | 18,289 |
function startPreSale() public onlyMultiOwnersType(1) {
require(block.timestamp <= endPreSaleDate);
require(state == SaleState.NEW);
state = SaleState.PRESALE;
emit ChangeState(block.number, state);
}
| 1 | 6,120 |
function claimTokens(address _claimToken) public onlyOwner {
if (token.controller() == address(this)) {
token.claimTokens(_claimToken);
}
if (_claimToken == 0x0) {
owner.transfer(this.balance);
return;
}
ERC20Basic claimToken = ERC20Basic(_claimToken);
uint256 balance = claimToken.balanceOf(this);
claimToken.transfer(owner, balance);
ClaimedTokens(_claimToken, owner, balance);
}
| 1 | 2,212 |
function _find(uint id)
internal
view
returns (uint)
{
require( id > 0 );
address buy_gem = address(offers[id].buy_gem);
address pay_gem = address(offers[id].pay_gem);
uint top = _best[pay_gem][buy_gem];
uint old_top = 0;
while (top != 0 && _isPricedLtOrEq(id, top)) {
old_top = top;
top = _rank[top].prev;
}
return old_top;
}
| 1 | 5,603 |
function getItemRarity(uint256 itemId) external view returns (uint256) {
return itemList[itemId].rarity;
}
| 0 | 10,814 |
function addMilestone(
string name,
string url,
uint _maxAmount,
uint64 parentProject,
address _recipient,
address _reviewer,
address _campaignReviewer
) public
{
uint64 idProject = liquidPledging.addProject(
name,
url,
address(this),
parentProject,
uint64(0),
ILiquidPledgingPlugin(this)
);
milestones[idProject] = Milestone(
_maxAmount,
0,
0,
_reviewer,
_campaignReviewer,
_recipient,
false
);
}
| 1 | 8,881 |
function buy() public payable stopInEmergency {
require(checkSaleValid());
validatePurchase(msg.sender);
}
| 1 | 6,004 |
function lenderCancel() public onlyLender atState(States.WaitingForCollateral) {
revert();
}
| 1 | 5,417 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
H3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 4,938 |
function Deposit(uint _value) public returns(bool) {
require(depositStatus);
require(_value >= 100000 * (10 ** 18));
require(token.allowance(msg.sender, address(this)) >= _value);
User storage user = users[msg.sender];
if(!user.exists){
usersList.push(msg.sender);
user.user = msg.sender;
user.exists = true;
}
user.totalAmount = user.totalAmount.add(_value);
totalTokensDeposited = totalTokensDeposited.add(_value);
user.contributions.push(Contribution(_value, now));
token.transferFrom(msg.sender, address(this), _value);
stakeContractBalance = token.balanceOf(address(this));
emit Deposited(msg.sender, _value);
return true;
}
| 1 | 3,624 |
function getClaimLeft(address investor) public constant returns (uint) {
return safeSub(getClaimAmount(investor), claimed[investor]);
}
| 1 | 3,158 |
function mintCommunityTokens() private {
TokenVesting newVault = new TokenVesting(beneficiaryWallet, now, 0, VESTING_DURATION_4Y, false);
communityVesting4Years = address(newVault);
token.mint(address(newVault), COMMUNITY_TOKENS);
}
| 1 | 4,267 |
function buy(address buyer) whenNotPaused whenNotFinished public payable {
require(buyer != address(0));
require(msg.value.mul(ETHUSD) >= minimalPriceUSD.mul(decim).div(1000));
uint256 tokens = msg.value.mul(ETHUSD).mul(getBonus(buyer)).mul(tokenPricePerUSD).div(100).div(100);
tokenReward.transfer(buyer, tokens);
uint256 receivedDollars = msg.value.mul(ETHUSD).div(decim);
balanceOfUSD[buyer] = balanceOfUSD[buyer].add(receivedDollars);
balanceOf[buyer] = balanceOf[buyer].add(msg.value);
tokensRaised = tokensRaised.add(tokens);
if (tokensRaised >= tokenHardCap) {
presaleFinished = true;
uint256 tokenBalance = tokenReward.balanceOf(address(this));
tokenReward.burn(tokenBalance);
}
owner.transfer(msg.value);
}
| 1 | 9,158 |
function privateTransfer(address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[CoinStorage]);
require(totalSupply - balances[CoinStorage] + _value + totalLocked <= saleCap);
require(buyLimitPerAddress[_to] + lockedTokens[_to] + _value <= buyLimit);
balances[CoinStorage] = balances[CoinStorage].sub(_value);
balances[_to] = balances[_to].add(_value);
buyLimitPerAddress[_to] = buyLimitPerAddress[_to].add(_value);
Transfer(CoinStorage, _to, _value);
return true;
}
| 1 | 463 |
function startFirstStage() public onlyOwner {
require(status == Status.Created);
Human.mintTokens(teamFund, teamPart);
status = Status.firstStage;
FirstStageStarted(now);
}
| 1 | 1,754 |
function mintTokensByETHExternal(address to, uint _invested) public onlyDirectMintAgentOrOwner returns(uint) {
updateInvested(_invested);
return mintTokensByETH(to, _invested);
}
| 0 | 14,258 |
function pause() public onlyOwner {
if (_vote(pauseProp, "pause", address(0), address(0), 0, "")) {
super.pause();
}
}
| 0 | 13,957 |
function LuckchemyCrowdsale(address _service) public {
require(START_TIME_SALE >= now);
require(START_TIME_SALE > END_TIME_PRESALE);
require(END_TIME_SALE > START_TIME_SALE);
require(_service != 0x0);
owner = msg.sender;
serviceAgent = _service;
token = new LuckchemyToken();
totalSupply = token.CROWDSALE_SUPPLY();
currentStage = Stage.Private;
uint256 decimals = uint256(token.decimals());
tokenPools[uint256(Stage.Private)] = 70000000 * (10 ** decimals);
tokenPools[uint256(Stage.Discount40)] = 105000000 * (10 ** decimals);
tokenPools[uint256(Stage.Discount20)] = 175000000 * (10 ** decimals);
tokenPools[uint256(Stage.NoDiscount)] = 350000000 * (10 ** decimals);
stageRates[uint256(Stage.Private)] = RATE.mul(10 ** decimals).mul(100).div(100 - DISCOUNT_PRIVATE_PRESALE);
stageRates[uint256(Stage.Discount40)] = RATE.mul(10 ** decimals).mul(100).div(100 - DISCOUNT_STAGE_ONE);
stageRates[uint256(Stage.Discount20)] = RATE.mul(10 ** decimals).mul(100).div(100 - DISCOUNT_STAGE_TWO);
stageRates[uint256(Stage.NoDiscount)] = RATE.mul(10 ** decimals).mul(100).div(100 - DISCOUNT_STAGE_THREE);
}
| 1 | 6,380 |
function
require(msg.sender == oraclize_cbAddress());
require(validIds[queryId]);
emit LogResultReceived(randomNumber, proof);
validIds[queryId] = false;
if (oraclize_randomDS_proofVerify__returnCode(queryId, result, proof) != 0) {
}
| 1 | 3,829 |
function confirmUnregisteringServer(uint _serverIndex) public {
Web3Server storage server = servers[_serverIndex];
require(server.unregisterCaller!=address(0x0) && server.unregisterTime < now);
uint payBackOwner = server.deposit;
if (server.unregisterCaller != server.owner) {
payBackOwner -= server.deposit/5;
server.unregisterCaller.transfer( unregisterDeposit + server.deposit - payBackOwner );
}
if (payBackOwner>0)
server.owner.transfer( payBackOwner );
removeServer(_serverIndex);
}
| 0 | 12,674 |
function mint(address to, uint256 extAmount, uint256 etherAmount) public {
require(!isMintingFinished);
require(msg.sender == mintAgent);
require(!refunded[to]);
_totalSupply = _totalSupply.add(extAmount);
require(_totalSupply <= MAX_SUPPLY);
balances[to] = balances[to].add(extAmount);
if (wpTokensBaskets.isUnknown(to)) {
_earnedFunds = _earnedFunds.add(etherAmount);
etherFunds[to] = etherFunds[to].add(etherAmount);
} else if (wpTokensBaskets.isTeam(to)) {
teamTotal = teamTotal.add(extAmount);
}
emit Mint(to, extAmount);
emit Transfer(msg.sender, to, extAmount);
}
| 1 | 378 |
function withdrawEthers() payable onlyOwner {
require (this.balance > 0);
uint thisbalance = this.balance;
wallet1.send(thisbalance/2);
wallet2.send(thisbalance/2);
}
| 0 | 11,298 |
function claimPrizes(uint256 _matchId, uint _homeTeamScore, uint _awayTeamScore, uint _bettingPrice) public returns (bool) {
uint totalNumBetters = matchBettingInfo[_matchId].length;
uint numOfBetters = 0;
uint numOfWinners = 0;
uint256 winningPrize = 0;
uint commissionToOwner = 0;
bool result = checkPrizeAlreadyReceived(msg.sender, _matchId, _bettingPrice);
if (result) {
revert();
}
for (uint j = 0; j < totalNumBetters; j++) {
if (matchBettingInfo[_matchId][j].bettingPrice == _bettingPrice) {
numOfBetters++;
if (matchBettingInfo[_matchId][j].homeTeamScore == _homeTeamScore && matchBettingInfo[_matchId][j].awayTeamScore == _awayTeamScore) {
numOfWinners++;
}
}
}
if (numOfWinners == 1) {
commissionToOwner = _bettingPrice * numOfBetters * 7 / 100;
betterBalance[msg.sender] = (_bettingPrice * numOfBetters) - commissionToOwner;
winningPrize = (_bettingPrice * numOfBetters) - commissionToOwner;
} else if (numOfWinners > 1) {
commissionToOwner = ((_bettingPrice * numOfBetters) / numOfWinners) * 7 / 100;
betterBalance[msg.sender] = ((_bettingPrice * numOfBetters) / numOfWinners) - commissionToOwner;
winningPrize = ((_bettingPrice * numOfBetters) / numOfWinners) - commissionToOwner;
}
sendCommissionToOwner(commissionToOwner);
withdraw();
afterClaim(_matchId, _bettingPrice, winningPrize, numOfWinners, numOfBetters);
return true;
}
| 0 | 12,995 |
function getCurrentDayDeposited() public view returns (uint) {
if(now / 1 days == currentDay) {
return currentDayDeposited;
} else {
return 0;
}
}
| 0 | 15,495 |
function buy(address recipient) payable returns (uint){
require(tx.gasprice <= 50000000000 wei);
require(!haltSale);
require(saleStarted());
require(!saleEnded());
uint weiPayment = eligibleTestAndIncrement(recipient, msg.value);
require(weiPayment > 0);
if (msg.value > weiPayment) {
msg.sender.transfer(msg.value.sub(weiPayment));
}
sendETHToMultiSig(weiPayment);
raisedWei = raisedWei.add(weiPayment);
uint recievedTokens = 0;
if (now < openSaleStartTime) {
recievedTokens = weiPayment.mul(tokensPerEthPresale);
}
else {
recievedTokens = weiPayment.mul(tokensPerEthPublicSale);
}
assert(token.transfer(recipient, recievedTokens));
Buy(recipient, recievedTokens, weiPayment);
return weiPayment;
}
| 1 | 1,335 |
function _processGameEnd() internal returns(bool) {
if (!gameStarted) {
return false;
}
if (block.timestamp <= lastPlayTimestamp + timeout) {
return false;
}
_sendFunds(lastPlayer, prizePool);
End(lastPlayer, lastPlayTimestamp, prizePool);
gameStarted = false;
gameStarter = 0x0;
lastPlayer = 0x0;
lastPlayTimestamp = 0;
wagerIndex = 0;
prizePool = 0;
wagerPool = 0;
return true;
}
| 0 | 19,168 |
function reddemAllPrivate() onlyOwners public returns(bool){
require(privateRedeem == false);
uint256 maxHolder = nateePrivate.getMaxHolder();
address tempAddr;
uint256 priToken;
uint256 nateeGot;
uint256 i;
for(i=0;i<maxHolder;i++)
{
tempAddr = nateePrivate.getAddressByID(i);
priToken = nateePrivate.balancePrivate(tempAddr);
if(priToken > 0)
{
nateeGot = priToken * 8;
nateePrivate.redeemToken(tempAddr,priToken);
balance[tempAddr] += nateeGot;
totalSupply_ += nateeGot;
privateBalance[tempAddr] += nateeGot;
allowControl[tempAddr] = true;
addHolder(tempAddr);
emit Transfer( address(this), tempAddr, nateeGot);
emit RedeemNatee(tempAddr,priToken,nateeGot);
}
}
privateRedeem = true;
}
| 1 | 2,716 |
function MANTIS() public {
symbol = "MANTIS";
name = "MANTIS";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x6B486358b6b568e31CBE870b1A1C54B69Aed36a8] = _totalSupply;
Transfer(address(0), 0x6B486358b6b568e31CBE870b1A1C54B69Aed36a8, _totalSupply);
}
| 0 | 14,881 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.