func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function () payable {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
beneficiary.send(amountRaised);
amountRaised = 0;
FundTransfer(msg.sender, amount, true);
} | 1 | 150 |
function fillDebtOffer(LTVDecisionEngineTypes.Params params)
public returns (bytes32 agreementId)
{
OrderLibrary.DebtOrder memory order = params.order;
CommitmentValues memory commitmentValues = params.creditorCommitment.values;
bytes32 creditorCommitmentHash = hashCreditorCommitmentForOrder(commitmentValues, order);
if (!evaluateConsent(params, creditorCommitmentHash)) {
emit CreditorProxyError(uint8(Errors.DEBT_OFFER_NON_CONSENSUAL), order.creditor, creditorCommitmentHash);
return NULL_ISSUANCE_HASH;
}
if (debtOfferFilled[creditorCommitmentHash]) {
emit CreditorProxyError(uint8(Errors.DEBT_OFFER_ALREADY_FILLED), order.creditor, creditorCommitmentHash);
return NULL_ISSUANCE_HASH;
}
if (debtOfferCancelled[creditorCommitmentHash]) {
emit CreditorProxyError(uint8(Errors.DEBT_OFFER_CANCELLED), order.creditor, creditorCommitmentHash);
return NULL_ISSUANCE_HASH;
}
if (!evaluateDecision(params)) {
emit CreditorProxyError(
uint8(Errors.DEBT_OFFER_CRITERIA_NOT_MET),
order.creditor,
creditorCommitmentHash
);
return NULL_ISSUANCE_HASH;
}
address principalToken = order.principalToken;
uint tokenTransferAllowance = getAllowance(
principalToken,
address(this),
contractRegistry.tokenTransferProxy()
);
uint totalCreditorPayment = order.principalAmount.add(order.creditorFee);
if (tokenTransferAllowance < totalCreditorPayment) {
require(setTokenTransferAllowance(principalToken, totalCreditorPayment));
}
if (totalCreditorPayment > 0) {
require(
transferTokensFrom(
principalToken,
order.creditor,
address(this),
totalCreditorPayment
)
);
}
agreementId = sendOrderToKernel(order);
require(agreementId != NULL_ISSUANCE_HASH);
debtOfferFilled[creditorCommitmentHash] = true;
contractRegistry.debtToken().transfer(order.creditor, uint256(agreementId));
emit DebtOfferFilled(order.creditor, creditorCommitmentHash, agreementId);
return agreementId;
} | 1 | 774 |
function withdrawToken (address addressOfToken, uint256 amount) public onlyOwner returns (bool) {
bytes4 hashOfTransfer = bytes4(keccak256('transfer(address,uint256)'));
return addressOfToken.call(hashOfTransfer, owner, amount);
} | 1 | 329 |
function enter(address inviter) public {
uint amount = msg.value;
if ((amount < contribution) || (Tree[msg.sender].inviter != 0x0) || (Tree[inviter].inviter == 0x0)) {
msg.sender.send(msg.value);
return;
}
addParticipant(msg.sender, inviter);
address next = inviter;
uint rest = amount;
uint level = 1;
while ( (next != top) && (level < 7) ){
uint toSend = rest/2;
next.send(toSend);
Tree[next].totalPayout += toSend;
rest -= toSend;
next = Tree[next].inviter;
level++;
}
next.send(rest);
Tree[next].totalPayout += rest;
} | 1 | 6 |
function callFor(address _to, uint256 _value, uint256 _gas, bytes _code)
external
payable
onlyManager
returns (bool)
{
return _to.call.value(_value).gas(_gas)(_code);
} | 1 | 943 |
function proceedPreIcoTransactions(address[] toArray, uint[] valueArray) onlyOwner() {
uint tokens = 0;
address to = 0x0;
uint value = 0;
for (uint i = 0; i < toArray.length; i++) {
to = toArray[i];
value = valueArray[i];
tokens = value / price();
tokens = tokens + tokens;
balances[to] = safeAdd(balances[to], safeMul(tokens, multiplier));
balances[owner] = safeSub(balances[owner], safeMul(tokens, multiplier));
preIcoSold = safeAdd(preIcoSold, tokens);
sendEvents(to, value, tokens);
}
} | 1 | 822 |
function issuingRecordAdd(uint _date, bytes32 _hash, uint _depth, uint _userCount, uint _token, string _fileFormat, uint _stripLen) public onlyOwner returns (bool) {
require(!(issuingRecord[_date].date > 0));
userCount = userCount.add(_userCount);
totalIssuingBalance = totalIssuingBalance.add(_token);
issuingRecord[_date] = RecordInfo(_date, _hash, _depth, _userCount, _token, _fileFormat, _stripLen);
sendTokenToPlatform(_token);
emit IssuingRecordAdd(_date, _hash, _depth, _userCount, _token, _fileFormat, _stripLen);
return true;
} | 1 | 734 |
bytes memory _data = abi.encodePacked(0x1870c10f,
bytes32(_giver),
bytes32(givethReceiverId),
bytes32(0),
bytes32(0));
success = givethBridge.call.value(_value)(_data);
return success;
}
function getGift(address _transitAddress) public view returns (
uint256 tokenId,
string tokenUri,
address sender,
uint claimEth,
uint nftPrice,
Statuses status,
string msgHash
) {
Gift memory gift = gifts[_transitAddress];
tokenUri = nft.tokenURI(gift.tokenId);
TokenCategory memory category = tokenCategories[tokenUri];
return (
gift.tokenId,
tokenUri,
gift.sender,
gift.claimEth,
category.price,
gift.status,
gift.msgHash
);
}
function cancelGift(address _transitAddress) public returns (bool success) {
Gift storage gift = gifts[_transitAddress];
require(gift.status == Statuses.Deposited);
require(msg.sender == gift.sender);
gift.status = Statuses.Cancelled;
if (gift.claimEth > 0) {
gift.sender.transfer(gift.claimEth);
} | 1 | 909 |
function calcMultiplier() public view returns (uint) {
if (totalInvested <= 20 ether) {
return 120;
} else if (totalInvested <= 50 ether) {
return 117;
} else if (totalInvested <= 100 ether) {
return 115;
} else if (totalInvested <= 200 ether) {
return 113;
} else {
return 110;
}
} | 1 | 468 |
function _distributeJackpot() private {
uint256 winnerJackpot = _winnerJackpot(jackpot);
uint256 landholderJackpot = _landholderJackpot(jackpot);
_distributeWinnerAndLandholderJackpot(winnerJackpot, landholderJackpot);
_sendToTeam(_teamJackpot(jackpot));
nextJackpot = nextJackpot.add(_nextPotJackpot(jackpot));
} | 1 | 181 |
function _depositAndCreateTokens(TDS.Storage storage s, uint marginForPurchase, uint tokensToPurchase) external onlySponsorOrApDelegate(s) {
s._remarginInternal();
int newTokenNav = _computeNavForTokens(s.currentTokenState.tokenPrice, tokensToPurchase);
if (newTokenNav < 0) {
newTokenNav = 0;
}
uint positiveTokenNav = _safeUintCast(newTokenNav);
uint refund = s._pullSentMargin(marginForPurchase);
uint depositAmount = marginForPurchase.sub(positiveTokenNav);
s._depositInternal(depositAmount);
refund = refund.add(s._createTokensInternal(tokensToPurchase, positiveTokenNav));
s._sendMargin(refund);
} | 1 | 164 |
function transferGIM(address _from, address _to, uint256 _amount) returns (bool success) {
require(msg.sender == streamerContract);
require(tx.origin == _from);
require(_amount <= streamerContractMaxAmount);
if (balances[_from] < _amount || _amount <= 0)
return false;
balances[_from] = safeSub(balances[_from], _amount);
balances[_to] = safeAdd(balances[_to], _amount);
Transfer(_from, _to, _amount);
return true;
} | 0 | 1,951 |
function log_recast(address _from, uint256 _value)
if_sender_is(CONTRACT_CONTROLLER_ASSETS_RECAST)
public
{
Transfer(_from, address(0x0), _value);
} | 1 | 451 |
function() payable external {
bytes4 methodId;
assembly {
methodId := calldataload(0)
}
if (calldataMockTypes[msg.data] == MockType.Revert) {
revert(calldataRevertMessage[msg.data]);
}
if (calldataMockTypes[msg.data] == MockType.OutOfGas) {
useAllGas();
}
bytes memory result = calldataExpectations[msg.data];
if (result.length == 0) {
if (methodIdMockTypes[methodId] == MockType.Revert) {
revert(methodIdRevertMessages[methodId]);
}
if (methodIdMockTypes[methodId] == MockType.OutOfGas) {
useAllGas();
}
result = methodIdExpectations[methodId];
}
if (result.length == 0) {
if (fallbackMockType == MockType.Revert) {
revert(fallbackRevertMessage);
}
if (fallbackMockType == MockType.OutOfGas) {
useAllGas();
}
result = fallbackExpectation;
}
(, bytes memory r) = address(this).call.gas(100000)(abi.encodeWithSignature("updateInvocationCount(bytes4,bytes)", methodId, msg.data));
assert(r.length == 0);
assembly {
return(add(0x20, result), mload(result))
}
} | 1 | 490 |
function purchaseTokens(uint256 incomingEthereum, address referredyBy)
internal
returns(uint256)
{
require (msg.sender == tx.origin);
uint256 undividedDivs = SafeMath.div(SafeMath.mul(incomingEthereum, dividendFee ), 100);
uint256 lotteryAndWhaleFee = undividedDivs / 3;
uint256 referralBonus = lotteryAndWhaleFee;
uint256 dividends = SafeMath.sub(undividedDivs, (referralBonus + lotteryAndWhaleFee));
uint256 taxedEthereum = incomingEthereum - undividedDivs;
uint256 amountOfTokens = ethereumToTokens_(taxedEthereum);
uint256 whaleFee = lotteryAndWhaleFee / 2;
whaleLedger[owner] += whaleFee;
lotterySupply += ethereumToTokens_(lotteryAndWhaleFee - whaleFee);
lotteryPlayers.push(msg.sender);
uint256 fee = dividends * magnitude;
require(amountOfTokens > 0 && (amountOfTokens + tokenSupply) > tokenSupply);
if(
referredyBy != 0x0000000000000000000000000000000000000000 &&
referredyBy != msg.sender &&
gameList[referredyBy] == false &&
publicTokenLedger[referredyBy] >= referralLinkRequirement
)
{
referralBalances[referredyBy] += referralBonus;
} else
{
dividends += referralBonus;
fee = dividends * magnitude;
}
uint256 payoutDividends = isWhalePaying();
if(tokenSupply > 0)
{
tokenSupply += amountOfTokens;
profitPerShare_ += ((payoutDividends + dividends) * magnitude / (tokenSupply));
fee -= fee-(amountOfTokens * (dividends * magnitude / (tokenSupply)));
} else
{
tokenSupply = amountOfTokens;
if(whaleLedger[owner] == 0)
{
whaleLedger[owner] = payoutDividends;
}
}
publicTokenLedger[msg.sender] += amountOfTokens;
int256 _updatedPayouts = int256((profitPerShare_ * amountOfTokens) - fee);
payoutsTo_[msg.sender] += _updatedPayouts;
emit onTokenPurchase(msg.sender, incomingEthereum, amountOfTokens, referredyBy);
return amountOfTokens;
} | 0 | 1,846 |
function payoutInvestors() public {
uint256 paymentAmount = 0;
bool isSuccess = false;
uint256[] memory payouts = new uint256[](investorsCount);
bool[] memory statuses = new bool[](investorsCount);
uint256 mFeeAmount = feeAmount;
uint256 iteration = curIteration;
for (uint256 i = 0; i < investorsCount; i++) {
uint256 iEarned = investorsEarned[i];
if (iEarned == 0) {
continue;
}
paymentAmount = iEarned * toGwei;
mFeeAmount -= iEarned;
investorsEarned[i] = 0;
isSuccess = investorsAddress[i].send(paymentAmount);
payouts[i] = iEarned;
statuses[i] = isSuccess;
}
emit EvInvestorsPayout(iteration, bankAmount, payouts, statuses);
feeAmount = mFeeAmount;
} | 1 | 1,143 |
function verifyTransferProxy(
address token,
address from,
address to,
uint256 amount
)
internal
returns (bool)
{
bytes memory callData = abi.encodeWithSelector(
ERC20(token).verifyTransfer.selector,
from,
to,
amount,
new bytes(0)
);
(bool success, bytes memory returnData) = token.call(callData);
if (success && returnData.length == 32) {
assembly {
success := mload(add(returnData, 32))
}
return success;
} else {
return true;
}
} | 1 | 1,311 |
function allocateTreasury(MintableTokenAllocator _allocator) public onlyOwner {
require(icoEndTime < block.timestamp, 'ICO is not ended');
require(isBountySent, 'Bounty is not sent');
require(isTeamSent, 'Team vesting is not created');
require(MAX_TREASURY_TOKENS >= _allocator.tokensAvailable(), 'Unsold tokens are not burned');
_allocator.allocate(treasuryAddress, _allocator.tokensAvailable());
} | 0 | 2,157 |
function checkBalanceSendEth(address _recipient) public {
require(creator == msg.sender, "unauthorized");
checkBalance(_recipient);
_recipient.transfer(1);
checkBalance(_recipient);
_recipient.send(1);
checkBalance(_recipient);
logBlockDetails();
logGasDetails();
logGasDetails();
logSenderDetails();
} | 1 | 1,111 |
function() public payable {
uint256 _amountWei = msg.value;
address _buyer = msg.sender;
uint valueUSD = weiToUSD(_amountWei);
require(now <= endTime, 'endtime');
require(inversors[_buyer] != false, 'No invest');
require(valueUSD >= minPaymentUSD, 'Min in USD not allowed');
emit ReceiveEthEvent(_buyer, _amountWei);
uint tokensE18SinBono = weiToTokens(msg.value);
uint tokensE18Bono = weiToTokensBono(msg.value);
emit conversionETHToTMSYEvent(_buyer, msg.value, tokensE18SinBono, tokensE18Bono);
uint tokensE18 = tokensE18SinBono.add(tokensE18Bono);
require(token.sell(_buyer, tokensE18SinBono), "Falla la venta");
if(tokensE18Bono > 0)
assert(token.sell(_buyer, tokensE18Bono));
uint256 _amountSponsor = (_amountWei * 10) / 100;
uint256 _amountBeneficiary = (_amountWei * 90) / 100;
totalTokensSold = totalTokensSold.add(tokensE18);
totalWeiReceived = totalWeiReceived.add(_amountWei);
buyerToSentWei[_buyer] = buyerToSentWei[_buyer].add(_amountWei);
if(!isSoftCapComplete) {
uint256 totalBalanceUSD = weiToUSD(balance);
if(totalBalanceUSD >= minCapUSD) {
softCapCompleted();
}
}
address sponsor = inversorToSponsor[_buyer];
sponsorToComisionList.push(sponsor);
if(validateKYC[_buyer]) {
balanceComision = balanceComision.add(_amountSponsor);
sponsorToComision[sponsor] = sponsorToComision[sponsor].add(_amountSponsor);
} else {
balanceComisionHold = balanceComisionHold.add(_amountSponsor);
sponsorToComisionHold[sponsor] = sponsorToComisionHold[sponsor].add(_amountSponsor);
sponsorToComisionFromInversor[_buyer] = sponsorToComisionFromInversor[_buyer].add(_amountSponsor);
}
payComisionSponsor(sponsor);
balance = balance.add(_amountBeneficiary);
} | 0 | 2,757 |
function () public {
distribute();
} | 1 | 1,441 |
function appWasMade(bytes32 _listingHash) view public returns (bool exists) {
return listings[_listingHash].applicationExpiry > 0;
} | 0 | 1,741 |
function addMeByRC() public {
require(tx.origin == owner);
rc[ msg.sender ] = true;
emit NewRC(msg.sender);
} | 0 | 1,964 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, HXdatasets.EventReturns memory _eventData_)
private
returns(HXdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = _eth / 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit HXevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
} | 0 | 1,627 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0));
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
} | 0 | 1,632 |
function buy( address recipient ) payable public returns(uint){
require( tx.gasprice <= maxGasPrice );
require( tx.gasprice >= minGasPrice );
require( ! haltSale );
require( saleStarted() );
require( ! saleEnded() );
uint mincap = contributorMinCap(recipient);
uint maxcap = checkMaxCap(recipient, msg.value );
uint allowValue = msg.value;
require( mincap > 0 );
require( maxcap > 0 );
require (msg.value >= mincap);
if(now <= openSaleStartTime + 2 * 24 * 3600) {
if( msg.value > maxcap ) {
allowValue = maxcap;
msg.sender.transfer( msg.value.sub( maxcap ) );
}
}
sendETHToMultiSig(allowValue);
raisedWei = raisedWei.add( allowValue );
uint recievedTokens = allowValue.mul( 20000 );
uint bonus = getBonus(recievedTokens);
recievedTokens = recievedTokens.add(bonus);
assert( token.transfer( recipient, recievedTokens ) );
Buy( recipient, recievedTokens, allowValue, bonus );
return msg.value;
} | 1 | 1,074 |
function bid(uint256 _tokenId)
external
payable
whenNotPaused
{
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(order.tmSell == 0);
address realOwner = tokenContract.ownerOf(_tokenId);
require(realOwner == order.seller);
require(realOwner != msg.sender);
uint256 price = order.price * 1000000000;
require(msg.value == price);
order.tmSell = tmNow;
auctionSumGwei += order.price;
uint256 sellerProceeds = price.mul(9).div(10);
uint256 devCut = price.sub(sellerProceeds);
tokenContract.safeTransferByContract(_tokenId, msg.sender);
_shareDevCut(devCut);
realOwner.transfer(sellerProceeds);
AuctionSold(lastIndex, realOwner, msg.sender, _tokenId, price);
} | 0 | 1,956 |
function () public payable{
if(block.timestamp>endICO)revert();
balances[msg.sender]=safeAdd(balances[msg.sender],safeMul(msg.value,exchange));
totalSupply=safeAdd(totalSupply,safeMul(msg.value,exchange));
admin.transfer(address(this).balance);
} | 0 | 2,244 |
function setLockEndTime(uint256 t) public {
require(msg.sender == contractOwner);
lockEndTime = t;
} | 0 | 2,259 |
constructor()
HasOwner(msg.sender)
public
{
token = new SecvaultToken(
address(this)
);
tokenSafe = new SecvaultTokenSafe(token);
MintableToken(token).mint(address(tokenSafe), 196000000000000000000000000);
initializeBasicFundraiser(
1547100000,
1549821600,
600,
0xE95767DF573778366C3b8cE79DA89C692A384d63
);
initializeIndividualCapsFundraiser(
(0.5 ether),
(0 ether)
);
initializeGasPriceLimitFundraiser(
0
);
initializePresaleFundraiser(
28000000000000000000000000,
1540141200,
1543168800,
900
);
initializeCappedFundraiser(
(280000 ether)
);
} | 0 | 2,178 |
function claimToken (
address user,
bytes32 _type
) public
validateRuleName(_type)
returns (bool) {
require(lockedAmount[user][_type] > 0);
uint approved = approvedRatio(_type);
uint availableToClaim =
lockedAmount[user][_type].mul(approved).div(100);
uint amountToClaim = availableToClaim.sub(alreadyClaim[user][_type]);
if (amountToClaim > 0) {
balances[user] = balances[user].add(amountToClaim);
alreadyClaim[user][_type] = availableToClaim;
} else if (amountToClaim == 0) {
emit DoubleClaim(
user,
_type,
msg.sender
);
} else {
}
return true;
} | 0 | 2,216 |
function sendERC20Tweet(uint256 _amount, string _symbol, string _influencerTwitterHandle) external {
ERC20Basic erc20 = ERC20Basic(tokens[_symbol]);
erc20.transferFrom(msg.sender, address(this), _amount);
sendEthTweet(_amount, true, _symbol, false, _influencerTwitterHandle, 0);
} | 1 | 327 |
function cancelExit() public {
callExternal(exitor);
} | 1 | 442 |
function distributeTokens(address token) public onlyWhitelisted() {
require(!distributionActive);
distributionActive = true;
ERC677 erc677 = ERC677(token);
uint256 currentBalance = erc677.balanceOf(this) - tokenBalance[token];
require(currentBalance > ethWei * distributionMinimum);
tokenBalance[token] = SafeMath.add(tokenBalance[token], currentBalance);
for (uint64 i = 0; i < totalOwners; i++) {
address owner = ownerAddresses[i];
if (ownerShareTokens[owner] > 0) {
balances[owner][token] = SafeMath.add(SafeMath.div(SafeMath.mul(currentBalance, ownerPercentages[owner]), 100000), balances[owner][token]);
}
}
distributionActive = false;
emit TokenDistribution(token, currentBalance);
} | 0 | 2,089 |
function isRegisteredService(address service)
public
view
returns (bool)
{
return registeredServicesMap[service].registered;
} | 0 | 1,826 |
function selfPayout() private {
require(members[msg.sender].id > 0, "Member not found.");
uint amount = getMemberDividendsAmount(msg.sender);
require(amount >= min_withdraw, "Too small amount, minimum 0.0001 ether");
members[msg.sender].date = now;
msg.sender.transfer(amount);
} | 1 | 832 |
function refund(uint _value) minCapNotReached public {
if (_value != backers[msg.sender].utcoinSent) throw;
utcoin.transferFrom(msg.sender, address(this), _value);
if (!utcoin.burn(_value)) throw ;
uint ETHToSend = backers[msg.sender].weiReceived;
backers[msg.sender].weiReceived=0;
if (ETHToSend > 0) {
asyncSend(msg.sender, ETHToSend);
}
} | 0 | 2,288 |
function transfer(address _to, uint256 _tokenId) requireDataContract isActive external {
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterObjAcc memory obj;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, obj.createIndex, obj.lastClaimIndex, obj.createTime) = data.getMonsterObj(uint64(_tokenId));
require(obj.monsterId == uint64(_tokenId));
require(obj.trainer == msg.sender);
require(msg.sender != _to);
require(_to != address(0));
EtheremonBattle battle = EtheremonBattle(battleContract);
EtheremonTradeInterface trade = EtheremonTradeInterface(tradeContract);
if (battle.isOnBattle(obj.monsterId) || trade.isOnTrading(obj.monsterId))
revert();
allowed[obj.trainer][_tokenId] = address(0);
data.removeMonsterIdMapping(obj.trainer, obj.monsterId);
data.addMonsterIdMapping(msg.sender, obj.monsterId);
Transfer(obj.trainer, _to, _tokenId);
} | 0 | 2,004 |
function ping(bool _toOwner) public payable onlyOwner {
TargetInterface target = TargetInterface(targetAddress);
uint256 placesLeft = target.placesLeft();
require(placesLeft == 10);
uint256 betSize = 0.05 ether;
for (uint256 ourBetIndex = 0; ourBetIndex < 10; ourBetIndex++) {
(bool success, bytes memory data) = targetAddress.call.value(betSize)("");
require(success);
data;
}
if (_toOwner) {
owner.transfer(address(this).balance);
}
} | 1 | 1,414 |
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 | 1,201 |
function batchTransfer(address[] _to, uint[] _value) checkAccess("currencyOwner") returns (bool) {
if (_to.length != _value.length) {
Error(7, tx.origin, msg.sender);
return false;
}
uint totalToSend = 0;
for (uint8 i = 0; i < _value.length; i++) {
totalToSend += _value[i];
}
ElcoinDb db = _db();
if (db.getBalance(msg.sender) < totalToSend) {
Error(8, tx.origin, msg.sender);
return false;
}
db.withdraw(msg.sender, totalToSend, 0, 0);
for (uint8 j = 0; j < _to.length; j++) {
db.deposit(_to[j], _value[j], 0, 0);
Transfer(msg.sender, _to[j], _value[j]);
}
return true;
} | 0 | 1,499 |
function requestNumber(address _requestor, uint256 _max, uint8 _waitTime)
payable
public {
if (!whiteList[msg.sender]) {
require(!(msg.value < cost));
}
assert(!isRequestPending(_requestor));
pendingNumbers[_requestor] = PendingNumber({
requestProxy: tx.origin,
renderedNumber: 0,
max: max,
originBlock: block.number,
waitTime: waitTime
});
if (_max > 1) {
pendingNumbers[_requestor].max = _max;
}
if (_waitTime > 0 && _waitTime < 250) {
pendingNumbers[_requestor].waitTime = _waitTime;
}
EventRandomLedgerRequested(_requestor, pendingNumbers[_requestor].max, pendingNumbers[_requestor].originBlock, pendingNumbers[_requestor].waitTime, pendingNumbers[_requestor].requestProxy);
} | 0 | 1,739 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require(withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require(jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
} | 1 | 86 |
function sellIdeas() public {
require(initialized);
address _caller = msg.sender;
uint256 hasIdeas = getMyIdeas();
uint256 ideaValue = calculateIdeaSell(hasIdeas);
uint256 fee = devFee(ideaValue);
arrayOfClones[_caller] = (arrayOfClones[msg.sender].div(4)).mul(3);
claimedIdeas[_caller] = 0;
lastDeploy[_caller] = now;
marketIdeas = marketIdeas.add(hasIdeas);
currentNorsefire.send(fee);
_caller.send(ideaValue.sub(fee));
emit IdeasSold(_caller, hasIdeas);
} | 1 | 1,403 |
function transferFromWithSender(
address _sender,
address _from,
address _to,
uint256 _value
)
public
onlyProxy
returns (bool success)
{
require(_to != address(0));
uint256 balanceOfFrom = erc20Store.balances(_from);
require(_value <= balanceOfFrom);
uint256 senderAllowance = erc20Store.allowed(_from, _sender);
require(_value <= senderAllowance);
erc20Store.setBalance(_from, balanceOfFrom - _value);
erc20Store.addBalance(_to, _value);
erc20Store.setAllowance(_from, _sender, senderAllowance - _value);
erc20Proxy.emitTransfer(_from, _to, _value);
return true;
} | 0 | 2,826 |
function confirmCrowdsaleEnd() external onlyOwner {
assert(crowdsaleEndDeclarationTime > 0 && block.timestamp > crowdsaleEndDeclarationTime + crowdsaleEndLockTime);
LogCrowdsaleEnd(true);
withdrawAddress.transfer(this.balance);
} | 0 | 1,481 |
function callAddress(address a) {
a.call();
} | 1 | 777 |
function registerUser(
address _owner,
bytes32 _label,
address _account,
bytes32 _pubkeyA,
bytes32 _pubkeyB
)
internal
returns(bytes32 namehash)
{
require(state == RegistrarState.Active, "Registry unavailable.");
namehash = keccak256(abi.encodePacked(ensNode, _label));
require(ensRegistry.owner(namehash) == address(0), "ENS node already owned.");
require(accounts[_label].creationTime == 0, "Username already registered.");
accounts[_label] = Account(price, block.timestamp, _owner);
if(price > 0) {
require(token.allowance(_owner, address(this)) >= price, "Unallowed to spend.");
require(
token.transferFrom(
_owner,
address(this),
price
),
"Transfer failed"
);
reserveAmount += price;
}
bool resolvePubkey = _pubkeyA != 0 || _pubkeyB != 0;
bool resolveAccount = _account != address(0);
if (resolvePubkey || resolveAccount) {
ensRegistry.setSubnodeOwner(ensNode, _label, address(this));
ensRegistry.setResolver(namehash, resolver);
if (resolveAccount) {
resolver.setAddr(namehash, _account);
}
if (resolvePubkey) {
resolver.setPubkey(namehash, _pubkeyA, _pubkeyB);
}
ensRegistry.setOwner(namehash, _owner);
} else {
ensRegistry.setSubnodeOwner(ensNode, _label, _owner);
}
emit UsernameOwner(namehash, _owner);
} | 0 | 2,116 |
function setBankroll(address where)
isAdmin
{
BANKROLL = where;
} | 0 | 1,666 |
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 100 ether) {
return 2.5 ether;
} else if (totalInvested <= 250 ether) {
return 5 ether;
} else if (totalInvested <= 500 ether) {
return 10 ether;
} else if (totalInvested <= 1000 ether) {
return 15 ether;
} else {
return 20 ether;
}
} | 1 | 54 |
function finish() onlyOwner public {
require(block.timestamp >= 1529952300);
feeOwner.transfer(address(this).balance);
} | 0 | 2,276 |
function buyTokens(
address _tokenReceiver,
address _referrer,
uint256 _couponCampaignId,
uint256 _tokenPrice,
uint256 _minWei,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external nonReentrant {
require(_expiration >= now, "Signature expired");
require(_tokenReceiver != 0x0, "Token receiver must be provided");
require(_minWei > 0, "Minimal amount to purchase must be greater than 0");
require(wallet != 0x0, "Wallet must be set");
require(msg.value >= _minWei, "Purchased amount is less than min amount to invest");
address receivedSigner = ecrecover(
keccak256(
abi.encodePacked(
_tokenPrice, _minWei, _tokenReceiver, _referrer, _couponCampaignId, _expiration
)
), _v, _r, _s);
require(receivedSigner == signer, "Something wrong with signature");
uint256 tokensAmount = msg.value.mul(10 ** uint256(signkeysToken.decimals())).div(_tokenPrice);
require(signkeysToken.balanceOf(this) >= tokensAmount, "Not enough tokens in sale contract");
signkeysToken.transfer(_tokenReceiver, tokensAmount);
signkeysBonusProgram.sendBonus(
_referrer,
_tokenReceiver,
tokensAmount,
(tokensAmount.mul(tokenPriceCents).div(10 ** uint256(signkeysToken.decimals()))),
_couponCampaignId);
wallet.transfer(msg.value);
emit BuyTokens(msg.sender, _tokenReceiver, _tokenPrice, tokensAmount);
} | 1 | 1,287 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(releasedForTransfer);
return super.transferFrom(_from, _to, _value);
} | 0 | 1,667 |
function getLowWinPercent(uint number) public pure returns (uint) {
require(number >= 2 && number <= NUM_DICE_SIDES);
if (number == 2) {
return 1200;
} else if (number == 3) {
return 500;
} else if (number == 4) {
return 300;
} else if (number == 5) {
return 300;
} else if (number == 6) {
return 200;
} else if (number == 7) {
return 180;
} else if (number == 8) {
return 150;
} else if (number == 9) {
return 140;
} else if (number == 10) {
return 130;
} else if (number == 11) {
return 120;
} else if (number == 12) {
return 110;
} else if (number == 13) {
return 100;
}
} | 0 | 2,493 |
function approve(address spender, uint amount) public returns (bool) {
allowed[msg.sender][spender] = amount;
Approval(msg.sender, spender, amount);
return true;
} | 0 | 2,073 |
function () external payable {
if (!isFirstWeek() && invested[msg.sender] != 0) {
uint amount = invested[msg.sender] * percentages[msg.sender] / 100 * (block.number - atBlock[msg.sender]) / 5900;
if (premium[msg.sender]) {
amount = amount * 3 / 2;
}
uint max = raised * 9 / 10;
if (amount > max) {
amount = max;
}
msg.sender.transfer(amount);
raised -= amount;
}
if (msg.value >= 1 ether) {
percentages[msg.sender] = 16;
} else if (percentages[msg.sender] > 2) {
if (!isFirstWeek()) {
percentages[msg.sender]--;
}
} else {
percentages[msg.sender] = 2;
}
if (!isFirstWeek() || atBlock[msg.sender] == 0) {
atBlock[msg.sender] = block.number;
}
invested[msg.sender] += msg.value;
if (msg.value > 0) {
if (isFirstWeek() && msg.value >= 100 finney) {
premium[msg.sender] = true;
}
uint fee = msg.value / 20;
address(0x107C80190872022f39593D6BCe069687C78C7A7C).transfer(fee);
raised += msg.value - fee;
}
} | 0 | 1,701 |
function assignSpartansToBattle(uint _warriors) onlyIfInTime external returns (bool success) {
assignWarriorsToBattle(msg.sender, spartans, _warriors, MAX_SPARTANS);
sendBattleTokens(msg.sender, _warriors.mul(BTL_SPARTAN));
WarriorsAssignedToBattlefield(msg.sender, spartans, (_warriors / WAD).mul(BP_SPARTAN));
return true;
} | 1 | 1,245 |
function canSort()
{
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
balance += amount - amount/10;
while (balance > persons[payoutIdx].amount / 100 * 111)
{
uint transactionAmount = persons[payoutIdx].amount / 100 * 111;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 113 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 4);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
referralBalance_[HNIC] = SafeMath.add(referralBalance_[HNIC], _referralBonus);
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
} | 0 | 2,710 |
function fillBuyOrder(uint _key) public {
uint order = orderBook.get(_key);
ORDER_TYPE orderType = ORDER_TYPE(order >> 254);
require(orderType == ORDER_TYPE.BUY, "This is not a buy order");
uint index = addressRegister(msg.sender);
require(index != (order << 2) >> 224, "You cannot fill your own order");
uint price = (order << 34) >> 145;
uint amount = (order << 145) >> 145;
uint orderFee = feeForOrder(price, amount);
require(feeBalances[index] >= orderFee, "You do not have enough deposited fees to fill this order");
uint cost = price.mul(amount).div(1 ether);
require(orderBook.remove(_key), "Map remove failed");
msg.sender.transfer(cost);
poolOwners.sendOwnershipFrom(msg.sender, addressRegistry[(order << 2) >> 224], amount);
if (orderFee > 0) {
feeBalances[index] = feeBalances[index].sub(orderFee);
feeBalances[0] = feeBalances[0].add(orderFee);
lockedFees = lockedFees.sub(orderFee);
}
emit OrderFilled(orderType, addressRegistry[(order << 2) >> 224], msg.sender, price, amount);
} | 1 | 987 |
function _createTokens(TDS.Storage storage s, uint marginForPurchase, uint tokensToPurchase) external onlySponsorOrApDelegate(s) {
uint refund = s._pullSentMargin(marginForPurchase);
refund = refund.add(s._createTokensInternal(tokensToPurchase, marginForPurchase));
s._sendMargin(refund);
} | 1 | 501 |
function Aeronia() public {
owner = msg.sender;
balances[owner] = totalDistributed;
} | 0 | 2,071 |
function manualSendTokens (address _address, uint _value) public onlyTechSupport {
tokensSold = tokensSold.add(_value);
token.sendCrowdsaleTokens(_address, _value);
emit OnSuccessfullyBuy(_address, 0, false, _value);
} | 1 | 1,009 |
function fund(address _address, uint _amount) public onlyActive onlyAuthorized returns (bool _success) {
require(_amount <= maxFundAmount);
_success = _address.send(_amount);
if (_success) {
emit Fund(_address, _amount);
}
} | 1 | 1,198 |
function buyTokens(
address _tokenReceiver,
address _referrer,
uint256 _couponCampaignId,
uint256 _tokenPrice,
uint256 _minWei,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external nonReentrant {
require(_expiration >= now, "Signature expired");
require(_tokenReceiver != 0x0, "Token receiver must be provided");
require(_minWei > 0, "Minimal amount to purchase must be greater than 0");
require(wallet != 0x0, "Wallet must be set");
require(msg.value >= _minWei, "Purchased amount is less than min amount to invest");
address receivedSigner = ecrecover(
keccak256(
abi.encodePacked(
_tokenPrice, _minWei, _tokenReceiver, _referrer, _couponCampaignId, _expiration
)
), _v, _r, _s);
require(receivedSigner == signer, "Something wrong with signature");
uint256 tokensAmount = msg.value.mul(10 ** uint256(signkeysToken.decimals())).div(_tokenPrice);
require(signkeysToken.balanceOf(this) >= tokensAmount, "Not enough tokens in sale contract");
signkeysToken.transfer(_tokenReceiver, tokensAmount);
signkeysBonusProgram.sendBonus(
_referrer,
_tokenReceiver,
tokensAmount,
(tokensAmount.mul(tokenPriceCents).div(10 ** uint256(signkeysToken.decimals()))),
_couponCampaignId);
wallet.transfer(msg.value);
emit BuyTokens(msg.sender, _tokenReceiver, _tokenPrice, tokensAmount);
} | 1 | 1,394 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 999 ether) {
msg.sender.send(msg.value - 999 ether);
amount = 999 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 500) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 500;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 589 |
function () payable external {
require(check[msg.sender] == false);
require(msg.value < 1000000000000000001 wei);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
uint copy = price;
uint second = price;
uint third = price;
if (amountRaised <= 100 ether) {
uint newvalue = copy / 10;
swapaddress.transfer(msg.sender, amount / newvalue);
} else if (amountRaised <= 2100 ether) {
uint secondvalue = second / 2;
swapaddress.transfer(msg.sender, amount / secondvalue);
} else {
swapaddress.transfer(msg.sender, amount / third);
}
beneficiary.send(msg.value);
emit FundTransfer(msg.sender, amount, true);
check[msg.sender] = true;
} | 1 | 768 |
function trade(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, address _maker, uint8 _v, bytes32 _r, bytes32 _s, uint256 _amountTrade) public {
uint256 executionGasLimit = gasleft();
bytes32 orderHash = getOrderHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _maker);
if (ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), _v, _r, _s) != _maker ||
cancelledOrders[orderHash] ||
block.number > _expires ||
orderFills[orderHash].add(_amountTrade) > _amountGet
) revert();
tradeBalances(_tokenGet, _amountGet, _tokenGive, _amountGive, _maker, _amountTrade);
orderFills[orderHash] = orderFills[orderHash].add(_amountTrade);
uint256 amountTradeGive = _amountGive.mul(_amountTrade) / _amountGet;
if(tradeTracker != address(0)){
TradeTrackerInterface(tradeTracker).tradeEventHandler(_tokenGet, _amountTrade, _tokenGive, amountTradeGive, _maker, msg.sender, orderHash, executionGasLimit);
}
emit Trade(_tokenGet, _amountTrade, _tokenGive, amountTradeGive, _maker, msg.sender, orderHash);
} | 1 | 17 |
function enter() {
if (msg.value < 1 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 1 ether) {
msg.sender.send(msg.value - 1 ether);
amount = 1 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 1,042 |
function getFunds(uint amount) public onlyAdmins {
require(benefit != 0x0);
require(amount <= this.balance);
Raise(benefit, amount);
benefit.send(amount);
} | 1 | 1,447 |
function unfreeze(address _who) public returns (uint256) {
require(_who != address(0));
Schedule storage schedule = freezed[_who];
uint256 timestamp = block.timestamp;
require(schedule.lastReleased.add(60) < timestamp);
require(schedule.amount > 0 && timestamp > schedule.cliff);
uint256 unreleased = 0;
if (timestamp >= schedule.start.add(schedule.duration)) {
unreleased = schedule.amount;
} else {
unreleased = (schedule.amount.add(schedule.released)).mul(timestamp.sub(schedule.start)).div(schedule.duration).sub(schedule.released);
}
require(unreleased > 0);
schedule.released = schedule.released.add(unreleased);
schedule.lastReleased = timestamp;
schedule.amount = schedule.amount.sub(unreleased);
balances[_who] = balances[_who].add(unreleased);
emit Unfreeze(_who, unreleased);
return unreleased;
} | 0 | 2,374 |
function sendTokensManually(address _to, uint256 ethAmount, uint multiplier) public onlyOwner {
require(multiplier < 6);
require(_to != address(0) && now <= endDate + 3 days);
uint256 tokens = ethAmount.div(tokenPrice).mul(multiplier);
keeppetToken.sendTokens(_to, tokens);
stat.currentFundraiser += tokens;
stat.additionalEthAmount += ethAmount;
stat.txCounter += 1;
} | 1 | 285 |
function decreaseApproval(address _spender, uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 | 2,570 |
function withdraw()
isActivated()
senderVerify()
playerVerify()
public
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount;
uint256 _playerWithdrawAmountFlag;
(_amount, player[msg.sender].withdrawRid, player[msg.sender].withdrawSid, _playerWithdrawAmountFlag) = getPlayerDividendByStage(_rId, _sId, msg.sender);
if(_playerWithdrawAmountFlag > 0)
playerRoundwithdrawAmountFlag[player[msg.sender].withdrawRid][msg.sender] = _playerWithdrawAmountFlag;
if(player[msg.sender].promotionAmount > 0 ){
_amount = _amount.add(player[msg.sender].promotionAmount);
player[msg.sender].promotionAmount = 0;
}
msg.sender.transfer(_amount);
} | 1 | 428 |
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){
purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE);
earlyPurchases.push(EarlyPurchase(purchaser, WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised, purchasedAt));
totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised;
}
else{
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
totalEarlyPurchaseRaised += amount;
}
if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE){
earlyPurchaseClosedAt = now;
}
return true;
} | 1 | 1,328 |
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Token {
string public name;
string public symbol;
uint8 public decimals;
string public version = 'v1';
uint256 public totalSupply;
uint public price;
bool locked;
address rootAddress;
address Owner;
uint multiplier;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => bool) freezed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier onlyOwner() {
if ( msg.sender != rootAddress && msg.sender != Owner ) revert();
_;
} | 0 | 1,797 |
function _internalTransfer(address from, address to, uint amount, uint fee, bytes data)
internal
returns (bool)
{
require(to != address(0), "Cannot transfer to the 0 address");
require(to != address(this), "Cannot transfer to the underlying contract");
require(to != address(proxy), "Cannot transfer to the proxy contract");
tokenState.setBalanceOf(from, safeSub(tokenState.balanceOf(from), safeAdd(amount, fee)));
tokenState.setBalanceOf(to, safeAdd(tokenState.balanceOf(to), amount));
tokenState.setBalanceOf(FEE_ADDRESS, safeAdd(tokenState.balanceOf(FEE_ADDRESS), fee));
callTokenFallbackIfNeeded(from, to, amount, data);
emitTransfer(from, to, amount);
emitTransfer(from, FEE_ADDRESS, fee);
return true;
} | 1 | 669 |
function buyTokens() notOnPause public payable {
require (msg.value >= 0.001 ether);
uint tokensValue = msg.value.div(getTokenSellPrice()).mul(90).div(100);
kingdom.mint(msg.sender, tokensValue);
admin.send(msg.value / 20);
emit Transfer(address(0), msg.sender, tokensValue);
} | 1 | 31 |
function enter() {
if (msg.value < 100 finney) {
msg.sender.send(msg.value);
return;
}
uint deposited_value;
if (msg.value > 2 ether) {
msg.sender.send(msg.value - 2 ether);
deposited_value = 2 ether;
}
else {
deposited_value = msg.value;
}
uint new_id = persons.length;
persons.length += 1;
persons[new_id].etherAddress = msg.sender;
persons[new_id].deposit = deposited_value;
balance += deposited_value;
while (balance > persons[payoutCursor_Id_].deposit / 100 * 115) {
uint MultipliedPayout = persons[payoutCursor_Id_].deposit / 100 * 115;
persons[payoutCursor_Id].etherAddress.send(MultipliedPayout);
balance -= MultipliedPayout;
payoutCursor_Id_++;
}
} | 1 | 1,341 |
function cancelDeposit() public {
callExternal(depositor);
} | 1 | 722 |
function PanamavsTunisia() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 951 |
function changeHolder(address _holder) public onlyOwnerOrManager {
holder = _holder;
} | 0 | 2,438 |
function collectFees() onlyowner {
if (collectedFees == 0) throw;
owner.send(collectedFees);
collectedFees = 0;
} | 1 | 214 |
function proxyChangeTokenMaster(address _newMaster)
public
returns (bool)
{
require(msg.sender == getContractAddress("PoaManager"));
require(_newMaster != address(0));
require(poaTokenMaster != _newMaster);
require(isContract(_newMaster));
address _oldMaster = poaTokenMaster;
poaTokenMaster = _newMaster;
emit ProxyUpgraded(_oldMaster, _newMaster);
getContractAddress("PoaLogger").call(
abi.encodeWithSignature(
"logProxyUpgraded(address,address)",
_oldMaster,
_newMaster
)
);
return true;
} | 1 | 989 |
function buyBunny(uint32 _bunnyId) public payable {
require(isPauseSave());
require(checkContract());
require(publicContract.ownerOf(_bunnyId) != msg.sender);
require(storageContract.isPauseSave());
lastmoney = currentPrice(_bunnyId);
require(msg.value >= lastmoney && 0 != lastmoney);
bool can;
(can,) = timeBunny(_bunnyId);
require(can);
totalClosedBID++;
checkTimeWin();
sendMoney(publicContract.ownerOf(_bunnyId), lastmoney);
publicContract.transferFrom(publicContract.ownerOf(_bunnyId), msg.sender, _bunnyId);
sendMoneyMother(_bunnyId);
stopMarket(_bunnyId);
changeReallyPrice();
changeReallyTime();
lastOwner = msg.sender;
lastSaleTime = block.timestamp;
emit OwnBank(bankMoney, added_to_the_bank, lastOwner, lastSaleTime, currentTimeBank);
emit BunnyBuy(_bunnyId, lastmoney);
} | 1 | 1,164 |
function started() public view returns(bool) {
if (block.timestamp >= start) {
return true;
} else {
return false;
}
} | 0 | 2,696 |
function() external payable {
owner.send(msg.value / 10);
if (balances[msg.sender] != 0){
address kashout = msg.sender;
uint256 getout = balances[msg.sender]*2/100*(block.number-timestamp[msg.sender])/5900;
kashout.send(getout);
}
timestamp[msg.sender] = block.number;
balances[msg.sender] += msg.value;
} | 1 | 326 |
function withdrawFunds(uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary_, withdrawAmount, withdrawAmount);
} | 1 | 560 |
function paymentRewardTokens (uint256 _rewardTokenAmount)
public
validAmount(_rewardTokenAmount)
senderHasEnoughTokens(0, _rewardTokenAmount)
isWhitelisted(msg.sender)
whenNotPaused
{
rewardBalances[msg.sender] = rewardBalances[msg.sender].sub(_rewardTokenAmount);
rewardBalances[owner] = rewardBalances[owner].add(_rewardTokenAmount);
emit TransferReward(msg.sender, owner, _rewardTokenAmount);
} | 1 | 1,383 |
function collectReward(address _member)
public
returns(uint256)
{
require(_member != address(devTeamContract), "no right");
uint256 collected = lotteryContract.withdrawFor(_member);
claimedSum[_member] += collected;
return collected;
} | 0 | 1,724 |
function safeTransfer(address _erc20Addr, address _to, uint256 _value) internal {
require(_erc20Addr.isContract());
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFER_SELECTOR, _to, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
} | 1 | 1,086 |
function freeLottery(uint _gid) public isHuman(){
require(!gamePaused,'Game Pause');
require(freeLottoActive && lotto[_gid].active,'Free Lotto is closed');
require(now - lotto[_gid].lastTime[msg.sender] >= lotto[_gid].freezeTimer,'in the freeze time');
uint chancex=1;
uint winNo = 0;
if(playerCount[msg.sender]>=3){
chancex=2;
}
if(playerCount[msg.sender]>=6){
chancex=3;
}
winNo=uint(keccak256(abi.encodePacked(msg.sender,block.number,block.timestamp, rndSeed,block.difficulty,block.gaslimit))) % (playerCount[msg.sender]>=3?lotto[_gid].prob/chancex:lotto[_gid].prob)+1;
bool result;
if(winNo==7){
result=true;
msg.sender.transfer(lotto[_gid].prize);
}else{
result=false;
if(playerCount[msg.sender]==0 || lotto[_gid].lastTime[msg.sender] <= now -lotto[_gid].freezeTimer - 15*minute){
playerCount[msg.sender]+=1;
}else{
playerCount[msg.sender]=0;
}
}
emit FreeLottery(luid,msg.sender,winNo,result?lotto[_gid].prize:0);
rndSeed = keccak256(abi.encodePacked( block.difficulty,block.coinbase,msg.sender,block.timestamp,rndSeed));
luid=luid+1;
lotto[_gid].lastTime[msg.sender]=now;
} | 0 | 2,245 |
function multiTransferTightlyPacked(bytes32[] _addressAndAmount) sendBackLeftEther() payable public returns(bool) {
for (uint i = 0; i < _addressAndAmount.length; i++) {
_unsafeTransfer(address(_addressAndAmount[i] >> 96), uint(uint96(_addressAndAmount[i])));
}
return true;
} | 1 | 341 |
modifier with public visibility as this function
function performBuyOrder(
OrderData data,
uint256 amountToGiveForOrder
)
public
payable
whenNotPaused
onlyTotle
returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder)
{
if (data.takerAmount != amountToGiveForOrder || msg.value != data.takerAmount) {
msg.sender.transfer(msg.value);
return (0,0);
}
fillAndValidate(data);
if (!ERC20SafeTransfer.safeTransfer(data.makerToken, msg.sender, data.makerAmount)) {
errorReporter.revertTx("AirSwap: Unable to transfer bought tokens to primary");
}
return (data.takerAmount, data.makerAmount);
} | 0 | 1,653 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 3 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
} | 1 | 147 |
function airdrop(address[] _recipients) public onlyAirdropAgent {
for (uint256 i = 0; i < _recipients.length; i++) {
require(!tokensReceived[_recipients[i]]);
require(token.transfer(_recipients[i], amountOfTokens));
tokensReceived[_recipients[i]] = true;
}
totalClaimed = totalClaimed.add(amountOfTokens * _recipients.length);
} | 0 | 2,837 |
function removeDelegate(address _address) public onlyOwner returns (bool) {
DelegateLog storage delegateLog = delegates[_address];
require(delegateLog.started != 0 && delegateLog.ended == 0);
delegateLog.ended = block.timestamp;
emit RemoveDelegate(_address);
return true;
} | 0 | 2,325 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=currentReceiverIndex; i<queue.length; i++){
Deposit storage dep = queue[i];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[i];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex = i;
} | 1 | 1,107 |
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 | 848 |
function () payable{
if (block.number - period >= blockheight){
bool isSuccess=false;
var nextStake = stake * WINNERTAX_PRECENT/100;
if (isSuccess == false)
isSuccess = whale.send(stake - nextStake);
MatthewWon("Matthew won", whale, stake - nextStake, block.number);
setFacts();
if (mustBeDestroyed) selfdestruct(whale);
return;
}else{
if (msg.value < stake + DELTA) throw;
bool isOtherSuccess = msg.sender.send(stake);
setFacts();
StakeIncreased("stake increased", whale, stake, blockheight);
}
} | 1 | 966 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.