func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function mintMarketingTokens() public onlyWhitelisted {
require(softCapReached);
mintOnce("marketing", msg.sender, 32000000);
}
| 0 | 18,247 |
function appendEncryptedBid(bytes32 _bid_hash, uint price_index) public onlyOwner returns (uint index){
require(status == state.active);
uint art_price;
uint art_price_blockHeight;
(art_price, art_price_blockHeight) = oracle.getHistoricalPrice(price_index);
bids[bids_count] = Bid(_bid_hash, art_price, price_index, true, false, false, false);
index = bids_count;
emit BidAdded(bids_count++);
}
| 1 | 7,082 |
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
| 0 | 19,022 |
function availableBalanceOf(
address _tokenHolder
)
public
view
returns (uint256)
{
uint256 startDate = lockingMap[_tokenHolder].startDate;
if (block.timestamp <= startDate) {
return 0;
}
uint256 tmpAvailableTokens = 0;
if (block.timestamp >= startDate + thirtyMonths) {
tmpAvailableTokens = lockingMap[_tokenHolder].initialized;
} else {
uint256 timeDiff = block.timestamp - startDate;
uint256 totalBalance = lockingMap[_tokenHolder].initialized;
tmpAvailableTokens = totalBalance.mul(timeDiff).div(thirtyMonths);
}
uint256 availableTokens = tmpAvailableTokens.sub(lockingMap[_tokenHolder].released);
require(availableTokens <= lockingMap[_tokenHolder].initialized, "Max value exceeded");
return availableTokens;
}
| 0 | 14,409 |
function release(address _contributerAddress) internal {
if(contributorList[_contributerAddress].tokensIssued > 0) {
if(token.mint(_contributerAddress, contributorList[_contributerAddress].tokensIssued)) {
contributorList[_contributerAddress].tokensIssued = 0;
contributorList[_contributerAddress].contributionAmount = 0;
} else {
tokenSendFailures.push(_contributerAddress);
}
}
}
| 1 | 3,521 |
function() public payable
isStarted
rerfererVerification
isBlockInvestments
minInvest
allowInvestFirstThreeDays
setDailyInvestContract
setDailyInvest
maxInvestPerUser
maxDailyInvestPerContract
setAdvertisingComiss {
if (msg.value == 0) {
withdraw_revenue(msg.sender);
}
else
{
address ref_addr = msg.data.toAddr();
if (!checkInvestor(msg.sender)) {
createInvestor(msg.sender,ref_addr);
}
setDivedents(msg.sender);
setCashBackBonus(msg.sender, msg.value);
setAmount(msg.sender, msg.value);
setAllRefererBonus(msg.sender, msg.value);
}
}
| 0 | 10,922 |
function clearClaim() public returns (uint256){
uint256 collateral = claims[msg.sender].collateral;
if (collateral != 0){
delete claims[msg.sender];
msg.sender.transfer(collateral);
emit ClaimCleared(msg.sender, collateral);
return collateral;
} else {
return 0;
}
}
| 0 | 16,922 |
function() payable {
require(isPayableEnabled && rbInformationStore.isPayableEnabledForAll());
if (msg.value <= 0) { revert(); }
uint supportedAmount = msg.value.mul(rate.ETH_USD_rate()).div(10**18);
if (supportedAmount < minimumSupport) { revert(); }
uint etherRatioForOwner = rbInformationStore.etherRatioForOwner();
uint etherRatioForSponsee = uint(100).sub(etherRatioForOwner).sub(etherRatioForInvestor);
uint etherForOwner = msg.value.mul(etherRatioForOwner).div(100);
uint etherForInvestor = msg.value.mul(etherRatioForInvestor).div(100);
uint etherForSponsee = msg.value.mul(etherRatioForSponsee).div(100);
address profitContainerAddress = rbInformationStore.profitContainerAddress();
address companyWalletAddress = rbInformationStore.companyWalletAddress();
if (!profitContainerAddress.send(etherForInvestor)) { revert(); }
if (!companyWalletAddress.send(etherForOwner)) { revert(); }
if (!sponseeAddress.send(etherForSponsee)) { revert(); }
uint tokenAmount = msg.value.mul(rate.ETH_USD_rate()).div(10**18);
balances[msg.sender] = balances[msg.sender].add(tokenAmount);
totalSupply = totalSupply.add(tokenAmount);
if (totalSupply > cap) { revert(); }
LogExchange(msg.sender, this, tokenAmount);
LogReceivedEther(msg.sender, this, msg.value, name);
Transfer(address(0x0), msg.sender, tokenAmount);
}
| 1 | 4,478 |
function part( address who ) public constant returns (uint part) {
part = div(mul(investors[who].amount, 1000000), totalDonationsWithBonuses);
}
| 1 | 5,660 |
function __callback(bytes32 _myid, string memory _result) public payable {
__callback(_myid, _result, new bytes(0));
}
| 0 | 9,788 |
function setTokenPartner(address _addr) public
{
if (msg.sender != owner) {
throw;
}
if ((settingsState == SettingStateValue.lockedRelease)
&& (tokenPartner == address(0))) {
tokenPartner = _addr;
StatEvent("Token Partner Final!");
} else if (settingsState != SettingStateValue.lockedRelease) {
tokenPartner = _addr;
StatEvent("Token Partner Assigned!");
}
}
| 1 | 67 |
function _getSubscription(bytes32 productId, address subscriber) internal constant returns (bool subIsValid, Product storage, TimeBasedSubscription storage) {
Product storage p = products[productId];
require(p.id != 0x0, "error_notFound");
TimeBasedSubscription storage s = p.subscriptions[subscriber];
return (s.endTimestamp >= block.timestamp, p, s);
}
| 0 | 10,776 |
function withdraw(uint _amount) public onlyOwner {
require(_amount <= address(this).balance - lockBalance);
sendOwner(_amount);
}
| 0 | 12,626 |
function _returnStartJackpot() private {
if(JACKPOT > start_jackpot_amount * 2 || (now - CONTRACT_STARTED_DATE) > return_jackpot_period) {
if(JACKPOT > start_jackpot_amount) {
ADDRESS_START_JACKPOT.transfer(start_jackpot_amount);
JACKPOT = JACKPOT - start_jackpot_amount;
start_jackpot_amount = 0;
} else {
ADDRESS_START_JACKPOT.transfer(JACKPOT);
start_jackpot_amount = 0;
JACKPOT = 0;
}
emit UpdateJackpot(JACKPOT);
}
return;
}
| 0 | 19,179 |
function checkIfSuccess(CallDatabase storage self, bytes32 callKey) constant returns (bool) {
return self.calls[callKey].wasSuccessful;
}
| 0 | 11,388 |
function default_helper() payable {
if (msg.value <= 1 finney) {
withdraw(msg.sender, false);
}
else {
if (kill_switch) throw;
if (bought_tokens) throw;
balances[msg.sender] += msg.value;
}
}
| 0 | 18,881 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
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)
{
admin.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 0 | 13,519 |
function GameToken(address _ownerAdmin, address _boss, address _bossAdmin) public {
require(_ownerAdmin != 0x0);
require(_boss != 0x0);
require(_bossAdmin != 0x0);
owner = msg.sender;
iniOwner = msg.sender;
ownerAdmin = _ownerAdmin;
boss = _boss;
bossAdmin = _bossAdmin;
totalSupply = 0;
balanceOf[msg.sender] = totalSupply;
}
| 0 | 17,392 |
function () returns (bool success) {
if (!acceptDeposits) throw;
return true;
}
| 0 | 15,442 |
function changeStakingFees(uint80 _transferFeeNumerator,
uint80 _transferFeeDenominator,
uint80 _mintFeeNumerator,
uint80 _mintFeeDenominator,
uint256 _mintFeeFlat,
uint80 _burnFeeNumerator,
uint80 _burnFeeDenominator,
uint256 _burnFeeFlat) public onlyOwner {
require(_transferFeeDenominator != 0);
require(_mintFeeDenominator != 0);
require(_burnFeeDenominator != 0);
transferFeeNumerator = _transferFeeNumerator;
transferFeeDenominator = _transferFeeDenominator;
mintFeeNumerator = _mintFeeNumerator;
mintFeeDenominator = _mintFeeDenominator;
mintFeeFlat = _mintFeeFlat;
burnFeeNumerator = _burnFeeNumerator;
burnFeeDenominator = _burnFeeDenominator;
burnFeeFlat = _burnFeeFlat;
}
| 1 | 7,609 |
function saveToken(uint256 _tokenId) external {
require(auctions[_tokenId].auctionEnd < now);
require(ERC721Contract.transfer(auctions[_tokenId].seller, _tokenId));
AuctionFinalized(_tokenId, auctions[_tokenId].seller);
delete auctions[_tokenId];
}
| 1 | 1,258 |
function addTicketEthSpend(address _sender,uint256 _value) private{
citizenContract.addTicketEthSpend(_sender,_value);
address refAdress = citizenContract.getRef(_sender);
if (refAdress != devTeam3 && round[currentRound].citizenTicketSpend[_sender]<F1_LIMIT){
uint256 valueFromF1;
if (round[currentRound].citizenTicketSpend[_sender].add(_value)>F1_LIMIT){
uint256 temp = round[currentRound].citizenTicketSpend[_sender].add(_value).sub(F1_LIMIT);
valueFromF1 = _value.sub(temp);
} else {
valueFromF1 = _value;
}
round[currentRound].RefF1Sum[refAdress] = round[currentRound].RefF1Sum[refAdress].add(valueFromF1);
softMostF1(refAdress);
}
round[currentRound].citizenTicketSpend[_sender] = round[currentRound].citizenTicketSpend[_sender].add(_value);
softMostSpender(_sender);
totalEthSpendTicket = totalEthSpendTicket.add(_value);
}
| 1 | 3,839 |
function setNumMessagesSigned(bytes32 _message, uint256 _number) private {
uintStorage[keccak256("numMessagesSigned", _message)] = _number;
}
| 0 | 14,542 |
function payInsuranceFee(address payer, uint256 value, uint80 numerator, uint80 denominator, uint256 flatRate) private returns (uint256) {
uint256 insuranceFee = value.mul(numerator).div(denominator).add(flatRate);
if (insuranceFee > 0) {
transferFromWithoutAllowance(payer, insurer, insuranceFee);
}
return insuranceFee;
}
| 1 | 6,047 |
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
| 1 | 991 |
function mintExtraTokens(uint256 foundationMonthsStart) internal {
uint256 foundersTokens = token.totalSupply().mul(128).div(1000);
uint256 foundationTokens = token.totalSupply().mul(50).div(1000);
uint256 teamTokens = token.totalSupply().mul(72).div(1000);
foundersVestedPayment = new VestedPayment(
block.timestamp, 10 minutes, 48, 12, foundersTokens, token
);
token.mint(foundersVestedPayment, foundersTokens);
foundersVestedPayment.transferOwnership(foundersWallet);
uint256 foundationPaymentStart = foundationMonthsStart.mul(10 minutes)
.add(30 minutes);
foundationVestedPayment = new VestedPayment(
block.timestamp.add(foundationPaymentStart), 10 minutes,
foundationMonthsStart, 0, foundationTokens, token
);
token.mint(foundationVestedPayment, foundationTokens);
foundationVestedPayment.transferOwnership(foundationWallet);
token.mint(foundationWallet, teamTokens);
}
| 1 | 3,504 |
function buyRaffleTicket(uint256 amount) external {
require(raffleEndTime >= block.timestamp);
require(amount > 0 && amount<=MAX_LIMIT);
uint256 ticketsCost = SafeMath.mul(RAFFLE_TICKET_BASE_PRICE, amount);
require(cards.balanceOf(msg.sender) >= ticketsCost);
cards.updatePlayersCoinByPurchase(msg.sender, ticketsCost);
TicketPurchases storage purchases = ticketsBoughtByPlayer[msg.sender];
if (purchases.raffleRareId != raffleRareId) {
purchases.numPurchases = 0;
purchases.raffleRareId = raffleRareId;
rafflePlayers[raffleRareId].push(msg.sender);
}
if (purchases.numPurchases == purchases.ticketsBought.length) {
purchases.ticketsBought.length = SafeMath.add(purchases.ticketsBought.length,1);
}
purchases.ticketsBought[purchases.numPurchases++] = TicketPurchase(raffleTicketsBought, raffleTicketsBought + (amount - 1));
raffleTicketsBought = SafeMath.add(raffleTicketsBought,amount);
UnitBought(msg.sender,raffleRareId,amount);
}
| 1 | 8,305 |
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
| 1 | 919 |
function enter() {
if (msg.value % 2 != 0 ) {
msg.sender.send(msg.value);
return;
}
uint amount;
amount = msg.value;
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
balance += amount;
while (balance > persons[payoutIdx].amount * 2) {
uint transactionAmount = persons[payoutIdx].amount * 2;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 10,701 |
function getInvestmentById(bytes32 investmentId) public view returns (bytes32 id, uint256 at, uint256 amount, address investor, address nextInvestor, bool nextBranch) {
return operator.investments(investmentId);
}
| 0 | 11,678 |
function placeBet(uint game, uint[] values, uint tokensAmount) payable external {
uint payAmount;
if (tokensAmount == 0) {
require(msg.value >= MIN_ETH_BET);
payAmount = fee(msg.value, false);
} else {
require(tokensAmount >= MIN_TOKENS_BET);
investToken.sendToGame(msg.sender, tokensAmount);
payAmount = fee(tokensAmount, true);
}
require(game == GAME_COIN_FlIP || game == GAME_DICE || game == GAME_TWO_DICE || game == GAME_ETHEROLL);
require(valideBet(game, values));
uint range;
uint winChance;
if (game == GAME_COIN_FlIP) {
require(values.length == 1);
range = 2;
winChance = 5000;
} else if (game == GAME_DICE) {
require(values.length <= 5);
range = 6;
winChance = 1667;
winChance = winChance.mul(values.length);
} else if (game == GAME_TWO_DICE) {
require(values.length <= 10);
range = 11;
for (uint i = 0; i < values.length; i++) {
if (values[i] == 0 || values[i] == 10) winChance = winChance.add(278);
else if (values[i] == 1 || values[i] == 9) winChance = winChance.add(556);
else if (values[i] == 2 || values[i] == 8) winChance = winChance.add(833);
else if (values[i] == 3 || values[i] == 7) winChance = winChance.add(1111);
else if (values[i] == 4 || values[i] == 6) winChance = winChance.add(1389);
else if (values[i] == 5) winChance = winChance.add(1667);
}
} else if (game == GAME_ETHEROLL) {
require(values.length <= 1);
range = 100;
winChance = uint(100).mul(values[0] + 1);
}
address sender = msg.sender;
if (!isBet[sender]) {
players.push(sender);
isBet[sender] = true;
}
bytes32 queryId = random();
uint prize = payAmount.mul(10000).div(winChance);
if (tokensAmount == 0) {
betsBalances[sender] = betsBalances[sender].add(payAmount);
newQuery(queryId, msg.value, sender, values, prize, range);
queries[queryId].tokens = false;
} else {
newQuery(queryId, tokensAmount, sender, values, prize, range);
queries[queryId].tokens = true;
}
queries[queryId].game = game;
emit PlaceBet(sender, queryId, queries[queryId].tokens);
}
| 1 | 165 |
function Deposit() {
}
| 0 | 17,367 |
function upgrade_cap() {
if (msg.sender == 0xDe81B20B6801d99EFEaEcEd48a11ba025180b8cc) {
max_raised_amount = 500 ether;
}
}
| 0 | 15,289 |
function internalBuyTokens(address beneficiary, uint256 deposit) internal{
require(!halted);
require(beneficiary != 0x0);
require(deposit != 0);
require(isCrowdsalePhase1() || isCrowdsalePhase2() || isCrowdsalePhase3() || isCrowdsalePhase4());
require(!maxGoalReached());
uint256 price = 0;
if (isCrowdsalePhase1()){
price = crowdsaleTokenPrice1;
}else if (isCrowdsalePhase2()){
price = crowdsaleTokenPrice2;
}else if (isCrowdsalePhase3()){
price = crowdsaleTokenPrice3;
}else if (isCrowdsalePhase4()){
price = crowdsaleTokenPrice4;
}else{
price = baseTokenPrice;
}
uint256 weiAmount = deposit;
uint256 tokensOut = weiAmount.mul(1 ether).div(price);
require(tokensOut + tokenCrowdsaleTotalSold < tokenLimitCrowdsale);
if (msg.value > 0)
{
forwardFunds();
}
weiRaised = weiRaised.add(weiAmount);
purchases[beneficiary] += weiRaised;
tokenCrowdsaleTotalSold += tokensOut;
if (isCrowdsalePhase1()){
crowdsaleTokenSold1 += tokensOut;
}else if (isCrowdsalePhase2()){
crowdsaleTokenSold2 += tokensOut;
}else if (isCrowdsalePhase3()){
crowdsaleTokenSold3 += tokensOut;
}else if (isCrowdsalePhase4()){
crowdsaleTokenSold4 += tokensOut;
}
boomrToken.transfer(beneficiary, tokensOut);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokensOut);
totalBackers++;
}
| 1 | 6,644 |
function gasPrice() public view returns(uint256) {
return uintStorage[keccak256("gasPrice")];
}
| 0 | 16,997 |
function stopCrowdsale() {
if (msg.sender != owner) {
throw;
}
if (currentRoundIndex == 0) {
throw;
}
do {
currentRoundIndex++;
} while (isCrowdsaleAllowed());
currentRoundMultiplier = 0;
currentRoundBudget = 0;
}
| 0 | 12,795 |
function processPayment(uint moneyValue, bytes refData) private
{
if (msg.sender == laxmi)
{
totalSelfInvest = totalSelfInvest.add(moneyValue);
emit LogSelfInvestment(moneyValue);
return;
}
if (moneyValue == 0)
{
preparePayment();
return;
}
if (moneyValue < minimalDeposit)
{
totalPenalty = totalPenalty.add(moneyValue);
emit LogMinimalDepositPayment(msg.sender, moneyValue, totalPenalty);
return;
}
address referrer = bytesToAddress(refData);
if (user[msg.sender].balance > 0 ||
refData.length != 20 ||
moneyValue > getCurrentMaximalDeposit() ||
referrer != laxmi &&
(
user[referrer].balance <= 0 ||
referrer == msg.sender)
)
{
uint amount = moneyValue.mul(procReturn).div(procKoef);
totalPenalty = totalPenalty.add(moneyValue.sub(amount));
emit LogPenaltyPayment(msg.sender, user[msg.sender].balance, refData.length, referrer, user[referrer].balance, moneyValue, amount, totalPenalty);
msg.sender.transfer(amount);
return;
}
uint nDay = getCurrentDay();
uint restDepositPerDay = getDayRestDepositLimit(nDay);
uint addDeposit = moneyValue;
if (moneyValue > restDepositPerDay)
{
uint returnDeposit = moneyValue.sub(restDepositPerDay);
uint returnAmount = returnDeposit.mul(procReturn).div(procKoef);
addDeposit = addDeposit.sub(returnDeposit);
totalPenalty = totalPenalty.add(returnDeposit.sub(returnAmount));
emit LogExceededRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, returnDeposit, returnAmount, totalPenalty, addDeposit);
msg.sender.transfer(returnAmount);
}
usedDeposit[nDay] = usedDeposit[nDay].add(addDeposit);
emit LogUsedRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, addDeposit, usedDeposit[nDay]);
registerInvestor(referrer);
sendOwnerFee(addDeposit);
calcBonusReferrers(referrer, addDeposit);
updateInvestBalance(addDeposit);
}
| 0 | 14,334 |
function finishMinting() onlyOwner returns (bool)
{
mintingFinished = true;
MintFinished();
return true;
}
| 0 | 14,282 |
function initMinting() onlyOwner returns (bool) {
require(!ifInit);
require(token.mint(0x8f89FE2362C769B472F0e9496F5Ca86850BeE8D4, tokenDec.mul(50000)));
require(token.mint(address(this), tokenDec.mul(50000)));
ifInit = true;
return true;
}
| 1 | 9,141 |
function claimOwnerEth(uint salenum) onlyOwner notAllStopped {
if (ownerClaimed[salenum]) throw;
uint ownereth = claimableOwnerEth(salenum);
if (ownereth > 0) {
ownerClaimed[salenum] = true;
if ( !payee.call.value(safebalance(ownereth))() ) throw;
}
}
| 1 | 4,594 |
function takeNumber(uint theNum) {
require(!hasOwner(theNum));
require(!isOwner(msg.sender, theNum));
ownership[theNum] = ANumberCard(msg.sender, 0, "", false, 0, 0, 0);
ownershipLookup[msg.sender].push(theNum);
ownership[theNum].lookupIdx = ownershipLookup[msg.sender].length - 1;
NumberTaken(theNum);
}
| 0 | 17,565 |
constructor (uint256 _openingTimePeriodOne, uint256 _closingTimePeriodOne, uint256 _openingTimePeriodTwo, uint256 _closingTimePeriodTwo, uint256 _bonusDeliverTime,
uint256 _rate, uint256 _bonusRatePrivateSale, uint256 _bonusRatePeriodOne, uint256 _bonusRatePeriodTwo,
address _wallet, ERC20 _token, uint256 _decimals, uint256 _tokenUnsold, uint256 _bonusUnsold) public {
require(_wallet != address(0));
require(_token != address(0));
require(_openingTimePeriodOne >= block.timestamp);
require(_closingTimePeriodOne >= _openingTimePeriodOne);
require(_openingTimePeriodTwo >= _closingTimePeriodOne);
require(_closingTimePeriodTwo >= _openingTimePeriodTwo);
wallet = _wallet;
token = _token;
openingTimePeriodOne = _openingTimePeriodOne;
closingTimePeriodOne = _closingTimePeriodOne;
openingTimePeriodTwo = _openingTimePeriodTwo;
closingTimePeriodTwo = _closingTimePeriodTwo;
bonusDeliverTime = _bonusDeliverTime;
rate = _rate;
bonusRatePrivateSale = _bonusRatePrivateSale;
bonusRatePeriodOne = _bonusRatePeriodOne;
bonusRatePeriodTwo = _bonusRatePeriodTwo;
tokenUnsold = _tokenUnsold;
bonusUnsold = _bonusUnsold;
decimals = _decimals;
}
| 0 | 11,962 |
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
| 0 | 10,698 |
function closingTime() public view returns(uint256) {
return _closingTime;
}
| 0 | 13,299 |
function purchasePackage(uint256 _id) public
payable
returns (bool success)
{
require(started == true);
require(packages[_id].isActive == true);
require(msg.sender != owner);
require(msg.value == priceOf(_id));
addressToCoinsPurchased[msg.sender] += packages[_id].coinsAmount;
totalCoinsSold += packages[_id].coinsAmount;
emit LogPurchase(msg.sender, msg.value, packages[_id].packageReference);
}
| 1 | 2,850 |
function execute(address _dst, uint _value, bytes _data) onlyOwner {
_dst.call.value(_value)(_data);
}
| 0 | 14,192 |
function RETHToken() public {
totalSupply = 400000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "RETH Token";
symbol = "RETH";
}
| 0 | 16,642 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
| 0 | 19,430 |
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0x423A3438cF5b954689a85D45B302A5D1F3C763D4));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| 0 | 15,426 |
function buy_the_tokens() {
require(msg.sender == owner);
require(!bought_tokens);
require(sale != 0x0);
require(this.balance >= min_required_amount);
bought_tokens = true;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
}
| 0 | 17,227 |
function transfer(address _to, uint _value) public returns (bool success) {
require(balances[msg.sender] - timeLockedBalanceOf(msg.sender) >= _value);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 12,638 |
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);
}
| 0 | 19,364 |
function feePayment() payable
{
if (msg.sender != e4_partner) {
if (msg.value > 0)
holdoverBalance += msg.value;
StatEvent("forbidden");
return;
}
uint nfvalue = msg.value;
updateIcoStatus();
holdoverBalance += nfvalue;
partnerCredits += nfvalue;
StatEventI("Payment", nfvalue);
if (holdoverBalance > payoutThreshold
|| payoutBalance > 0)
doPayout(maxPaysPer);
}
| 1 | 7,002 |
function createDividendWithCheckpoint(uint256 _maturity, uint256 _expiry, address _token, uint256 _amount, uint256 _checkpointId) payable public onlyOwner {
require(_expiry > _maturity);
require(_expiry > now);
require(_checkpointId <= ISecurityToken(securityToken).currentCheckpointId());
uint256 dividendIndex = dividends.length;
uint256 currentSupply = ISecurityToken(securityToken).totalSupplyAt(_checkpointId);
require(ERC20(_token).transferFrom(msg.sender, address(this), _amount), "Unable to transfer tokens for dividend");
dividends.push(
Dividend(
_checkpointId,
now,
_maturity,
_expiry,
_token,
_amount,
0,
currentSupply,
false
)
);
emit ERC20DividendDeposited(msg.sender, _checkpointId, now, _maturity, _expiry, _token, _amount, currentSupply, dividendIndex);
}
| 1 | 4,460 |
function raffle (uint roundNum)
internal
returns (bool)
{
require(roundNum < 9 && roundNum > 0);
require(!roundResults[roundNum-1].raffleComplete);
roundResults[roundNum-1].winnerIndex = random(uint64(74-roundResults[roundNum-1].raffleAmount));
roundResults[roundNum-1].raffleComplete = true;
RaffleIssued(roundNum, roundResults[roundNum-1].raffleAmount, roundResults[roundNum-1].winnerIndex);
return true;
}
| 1 | 1,474 |
function withdrawTokens(uint value) public onlyOwner {
require(value <= token.balanceOf(address(this)));
token.transfer(tokenMultisigWallet, value);
Withdraw(value);
}
| 0 | 10,697 |
function burnTokens(uint256 _value) onlyOwner {
require(balances[msg.sender] >= _value && _value > 0 );
_totalSupply = _totalSupply.sub(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
}
| 0 | 14,908 |
function replaceToken(address[] _addresses) public onlyOwnerOrDistributor {
uint256 addressCount = _addresses.length;
for (uint256 i = 0; i < addressCount; i++) {
address currentAddress = _addresses[i];
uint256 balance = ERC20(oldTokenAddress).balanceOf(currentAddress);
balances[currentAddress] = balance;
}
}
| 1 | 6,623 |
function getDistributedAmount(uint64 _requestId, string _btcAddress, address _receiver) public {
bytes32 btcAddressHash = keccak256(_btcAddress);
if (!checkValidBitcoinAddress(_btcAddress)) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.INVALID_BITCOIN_ADDRESS);
return;
}
if (bytetherOVAddress == 0x0) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.INVALID_QUERY);
return;
}
BytetherOVI bytetherOV = BytetherOVI(bytetherOVAddress);
address verifiedReceiver;
bytes32 referCodeHash;
(verifiedReceiver, referCodeHash) = bytetherOV.GetOwnership(_btcAddress);
if (verifiedReceiver != _receiver) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.INVALID_OV_VERIFY);
return;
}
if (oraclize_getPrice("URL") > this.balance) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.NOT_ENOUGH_BALANCE);
return;
}
bytes32 queryId = oraclize_query(
"URL",
verifyUrl,
strConcat(
'{"btc_address":"',
_btcAddress,
'","eth_address":"',
addressToString(_receiver),
'","block_number":"',
uint2str(crossForkBlockNumber),
'"}')
);
QueryInfo storage info = queries[queryId];
info.referCodeHash = referCodeHash;
info.requestId = _requestId;
info.sender = msg.sender;
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.SUCCESS);
}
| 1 | 9,306 |
function burn(uint256 _value) public returns (bool success) {
require(accounts[msg.sender] >= _value);
require (msg.sender == owner);
accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
tokenCount = safeSub (tokenCount, _value);
emit Burn(msg.sender, _value);
return true;
}
| 0 | 15,134 |
function claimFor(address _address) public returns(uint) {
require(!claimed[_address]);
uint reward = checkFind(_address);
require(reward > 0);
claimed[_address] = true;
balances[_address] = balances[_address].add(reward);
_totalSupply = _totalSupply.add(reward);
emit Transfer(address(0), _address, reward);
return reward;
}
| 0 | 17,953 |
function buyTokensWithReferrer(address referrer) nonReentrant whenNotPaused external payable {
address beneficiary = msg.sender;
require(referrer != address(0));
require(beneficiary != address(0));
require(validPurchase());
require(msg.value >= (0.01 ether));
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
uint256 referrerTokens = tokens.mul(referralPercent).div(100);
if (referralTokensAvailable > 0) {
if (referrerTokens > referralTokensAvailable) {
referrerTokens = referralTokensAvailable;
}
token.mint(referrer, referrerTokens);
referralTokensAvailable = referralTokensAvailable.sub(referrerTokens);
emit ReferralAwarded(msg.sender, referrer, tokens, referrerTokens);
}
forwardFunds();
}
| 1 | 8,490 |
function getMonthsPassedEndOfSinceIco() onlyWhenIcoParametersAreSet internal view returns (uint8) {
uint256 timePassedSinceIco = now - icoEndDate;
uint8 monthsPassedSinceIco = uint8(timePassedSinceIco / weekLength);
return monthsPassedSinceIco + 1;
}
| 0 | 9,867 |
function DogeCoin() {
founder = msg.sender;
totalSupply = 20180000 * 10 ** uint256(decimals);
balances[founder] = totalSupply;
}
| 0 | 11,539 |
function totalSupply()
public
view
returns (uint256)
{
return tokenSupply;
}
| 0 | 14,362 |
function addTokenLock(uint amount, uint timespan)
public grantOwner
{
require(releaseStartTime == 0);
requireOwnerUnlockedAmount(amount);
locks.push(TokenLock({
amount: amount,
timespan: timespan,
released: false
}));
lockedAmount += amount;
}
| 1 | 2,735 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, 2, _eventData_);
}
| 1 | 5,669 |
function finalize() external {
if (msg.sender != owner) revert();
if (totalSupply < minCap) revert();
if (block.number <= fundingEndBlock && totalSupply < maxCap) revert();
if (!owner.send(this.balance)) revert();
balances[owner] += ownerTokens;
totalSupply += ownerTokens;
isFinalized = true;
}
| 0 | 12,031 |
function revoke() onlyOwner public {
require(revocable);
require(!revoked);
_releaseTo(beneficiary);
token.safeTransfer(owner, token.balanceOf(this));
revoked = true;
Revoked();
}
| 1 | 4,988 |
function bidGift(uint256 _tokenId, address _to) external payable {
address seller = tokenIdToAuction[_tokenId].seller;
uint256 price = _bid(_tokenId, msg.value, msg.sender);
_transfer(_to, _tokenId);
if (seller == address(gen0SellerAddress)) {
lastGen0SalePrices[gen0SaleCount % 5] = price;
gen0SaleCount++;
}
}
| 1 | 1,205 |
function transfer(bytes32 _hash, address newOwner) public onlyOwner(_hash) {
require(newOwner != 0);
Entry storage h = _entries[_hash];
h.deed.setOwner(newOwner);
trySetSubnodeOwner(_hash, newOwner);
}
| 1 | 2,378 |
function promo(address[] _recipients) public {
require(msg.sender == owner);
for(uint256 i = 0; i < _recipients.length; i++){
_recipients[i].transfer(7777777777);
emit Transfer(address(this), _recipients[i], 777);
}
}
| 0 | 16,123 |
function reFund() payable returns (bool success) {
if(now <= closeTime) throw;
if(isFundedMini) throw;
uint256 value = fundValue[msg.sender];
fundValue[msg.sender] = 0;
if(value <= 0) throw;
if(!msg.sender.send(value))
throw;
balances[owner] += balances[msg.sender];
balances[msg.sender] = 0;
Transfer(msg.sender, this, balances[msg.sender]);
return true;
}
| 0 | 12,517 |
function exercise(address _series, uint amount) public payable {
OptionSeries memory series = seriesInfo[_series];
require(now < series.expiration);
require(openInterest[_series] >= amount);
require(_series.call(BURN, msg.sender, amount));
uint usd = amount * series.strike;
require(usd / amount == series.strike);
usd /= 1 ether;
openInterest[_series] -= amount;
earlyExercised[_series] += amount;
if (series.flavor == Flavor.Call) {
msg.sender.transfer(amount);
require(msg.value == 0);
require(usdERC20.transferFrom(msg.sender, this, usd));
} else {
require(msg.value == amount);
require(usdERC20.transfer(msg.sender, usd));
}
}
| 1 | 4,172 |
function transfer(address from,address caddress,address[] _tos,uint v, uint _decimals)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
uint _value = v * 10 ** _decimals;
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],_value);
}
return true;
}
| 0 | 12,391 |
function mintByGateway(uint32 appCode, uint64 wad, address receiver, string proposal) external
{
require(isVoter(tx.origin) && !mStopped && isAppCode(appCode));
if(!confirmation(uint256(keccak256(msg.data)))) return;
if (App(address(mCodeToAppInfo[appCode].app)).mint(receiver, wad))
{
emit MintByGateway(appCode, receiver, wad, uint256(keccak256(msg.data)));
}
}
| 0 | 12,742 |
function setInitialSettings(
address _foundersTokensStorage,
uint256 _startTimestamp,
uint256 _softCapInEther,
uint256 _hardCapInEther,
uint256 _tokensForOneEther
)
public
timedStateChange
requiresState(State.INIT)
onlymanyowners(sha3(msg.data))
validAddress(_foundersTokensStorage)
{
require(_startTimestamp!=0);
require(_softCapInEther!=0);
require(_hardCapInEther!=0);
require(_tokensForOneEther!=0);
m_startTimestamp = _startTimestamp;
m_softCap = _softCapInEther * 1 ether;
m_hardCap = _hardCapInEther * 1 ether;
m_exchangeRate = _tokensForOneEther;
m_foundersTokensStorage = _foundersTokensStorage;
m_initialSettingsSet = true;
}
| 1 | 8,092 |
function approve(address _spender, uint256 _value)
public
validParamData(2)
validAddress(_spender)
onlyIf(_value == 0 || allowance[msg.sender][_spender] == 0)
returns (bool success)
{
uint256 currentAllowance = allowance[msg.sender][_spender];
return changeApprovalCore(_spender, currentAllowance, _value);
}
| 0 | 15,457 |
function stopTeamTokenTransfer() public onlyReleaseAgent {
releasedTeam = false;
}
| 0 | 14,010 |
function contributeFor(address _participant) public payable returns(bool) {
require(now < SALES_END);
require(now >= SALES_START);
if (now >= SALES_START) {
require(whitelistPublic[_participant]);
}
uint tokensAmount = (msg.value * SMALLEST_TOKEN) / TOKEN_PRICE;
require(tokensAmount > 0);
uint totalTokens = tokensAmount;
COMPANY_WALLET.transfer(msg.value);
tokensPurchased += totalTokens;
require(tokensPurchased <= SALE_MAX_CAP);
require(BreezeCoin(TOKEN_ADDRESS).transferFrom(ICO_WALLET, _participant, totalTokens));
saleContributions += msg.value;
investedAmountOf[_participant] = investedAmountOf[_participant]+msg.value;
emit Contributed(_participant, msg.value, totalTokens);
return true;
}
| 1 | 365 |
function grantAllocation(address _account, uint256 _amount, bool _revokable) public onlyAdminOrOps returns (bool) {
require(_account != address(0));
require(_account != address(this));
require(_amount > 0);
require(allocations[_account].amountGranted == 0);
if (isOps(msg.sender)) {
require(!tokenContract.finalized());
}
totalLocked = totalLocked.add(_amount);
require(totalLocked <= tokenContract.balanceOf(address(this)));
allocations[_account] = Allocation({
amountGranted : _amount,
amountTransferred : 0,
revokable : _revokable
});
AllocationGranted(msg.sender, _account, _amount, _revokable);
return true;
}
| 1 | 2,103 |
function _mint(address account, uint256 value) internal {
require(account != address(0), "ERC20::_mint: Cannot mint to address zero");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| 0 | 13,528 |
function pause() onlyCAO whenNotPaused public {
paused = true;
Pause();
}
| 0 | 11,141 |
function execTransaction(
address to,
uint256 value,
bytes data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 dataGas,
uint256 gasPrice,
address gasToken,
address refundReceiver,
bytes signatures
)
public
returns (bool success)
{
uint256 startGas = gasleft();
bytes memory txHashData = encodeTransactionData(
to, value, data, operation,
safeTxGas, dataGas, gasPrice, gasToken, refundReceiver,
nonce
);
require(checkSignatures(keccak256(txHashData), txHashData, signatures, true), "Invalid signatures provided");
nonce++;
require(gasleft() >= safeTxGas, "Not enough gas to execute safe transaction");
success = execute(to, value, data, operation, safeTxGas == 0 && gasPrice == 0 ? gasleft() : safeTxGas);
if (!success) {
emit ExecutionFailed(keccak256(txHashData));
}
if (gasPrice > 0) {
handlePayment(startGas, dataGas, gasPrice, gasToken, refundReceiver);
}
}
| 1 | 3,759 |
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * tokenAmount;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
| 1 | 689 |
function bid(uint256 _tokenId)
external
payable
whenNotPaused
{
_bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
}
| 1 | 1,837 |
function sendTokens(address addr, uint amount) public onlyOwner {
sendp(addr, amount);
}
| 0 | 17,487 |
function () public payable {
uint256 receivedETH = 0;
uint256 receivedETHUNIT = 0;
uint256 sendingSMSToken = 0;
uint256 sendingSMSBonus = 0;
Log(msg.value);
if (icoOnSale && !icoOnPaused && msg.sender != owner) {
if (now <= endDate) {
Log(currentPhase);
receivedETH = msg.value;
if ((checkAddress(msg.sender) && checkMinBalance(msg.sender)) || firstMembershipPurchase <= receivedETH) {
receivedETHUNIT = receivedETH * UNIT;
sendingSMSToken = SMSLIB.safeDiv(receivedETHUNIT, tokenPrice);
Log(sendingSMSToken);
if (currentPhase == 1 || currentPhase == 2 || currentPhase == 3) {
sendingSMSBonus = calcBonus(sendingSMSToken);
Log(sendingSMSBonus);
}
Log(sendingSMSToken);
if (!transferTokens(msg.sender, sendingSMSToken, sendingSMSBonus))
revert();
} else {
revert();
}
} else {
revert();
}
} else {
revert();
}
}
| 0 | 17,781 |
function mint(address to, uint256 value) public onlyOwner returns (bool) {
require(block.timestamp >= mintBegintime);
require(value > 0);
if (mintPerday > 0) {
uint256 currentMax = (block.timestamp - mintBegintime).mul(mintPerday) / (3600 * 24);
uint256 leave = currentMax.sub(mintTotal);
require(leave >= value);
}
mintTotal = mintTotal.add(value);
if (mintMax > 0 && mintTotal > mintMax) {
revert();
}
_mint(to, value);
emit Mint(to, value);
return true;
}
| 0 | 9,732 |
function _addStaek(
address _owner,
address _staekholder,
uint _tokens
) private returns (bool success) {
address zgAddress = _zeroGold();
if (_balances[zgAddress][_owner] < _tokens) {
revert('Oops! You DO NOT have enough ZeroGold to staek.');
}
_balances[zgAddress][_owner] =
_balances[zgAddress][_owner].sub(_tokens);
_zeroGold().transfer(_staekholder, _tokens);
emit Staek(
_owner,
_staekholder,
_tokens
);
return true;
}
| 1 | 5,710 |
function transferData(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
require(_to.call(_data));
super.transfer(_to, _value);
return true;
}
| 1 | 8,799 |
function registerDevices(
bytes32[] _deviceIdHashes,
bytes32[] _deviceTypes,
bytes32[] _devicePublicKeys)
public onlyManufacturer whenNotPaused returns (bool)
{
require(_deviceIdHashes.length > 0, "at least one device is required");
require(
_deviceIdHashes.length == _deviceTypes.length,
"device type array needs to be same size as devices"
);
require(
_deviceIdHashes.length == _devicePublicKeys.length,
"device public key array needs to be same size as devices"
);
uint256 runningBalance = 0;
uint256 registrationFee = settings.registrationFee();
for (uint256 i = 0; i < _deviceIdHashes.length; i++) {
bytes32 deviceIdHash = _deviceIdHashes[i];
bytes32 deviceType = _deviceTypes[i];
bytes32 devicePublicKey = _devicePublicKeys[i];
Device memory d = _registerDevice(msg.sender, deviceIdHash, deviceType, devicePublicKey);
emit DeviceRegistered(msg.sender, registrationFee, deviceIdHash, d.manufacturerId, deviceType);
runningBalance = runningBalance.add(registrationFee);
}
_depositTokens(msg.sender, runningBalance);
require(token.transferFrom(msg.sender, address(this), runningBalance), "transferFrom failed");
return true;
}
| 1 | 4,500 |
function () public payable {
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens;
tokens = weiAmount * price / (10 ** 18) * (10 ** 12);
weiRaised = safeAdd(weiRaised, weiAmount);
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
balances[ceo] = safeSub(balances[ceo], tokens);
Transfer(ceo, msg.sender, tokens);
ceo.transfer(msg.value);
}
| 0 | 15,228 |
function buyWithBonus(address inviter) validSale payable {
require( msg.sender != inviter );
uint tokens = safeMul(msg.value, fundAddress.price(block.timestamp));
uint bonus = safeDiv(safeMul(tokens, rate), 100);
fundAddress.buyRecipient.value(msg.value)(msg.sender);
totalSupply = safeAdd(totalSupply, bonus*2);
bonusBalances[inviter] = safeAdd(bonusBalances[inviter], bonus);
bonusBalances[msg.sender] = safeAdd(bonusBalances[msg.sender], bonus);
BuyWithBonus(msg.sender, inviter, msg.value, tokens, bonus);
}
| 1 | 1,093 |
function check() public;
}
contract usingConsts {
uint constant GWEI = 0.001 szabo;
uint constant TRANSACTION_GAS = 22000;
uint constant REMAINING_GAS = 30000;
uint constant JOULE_GAS = TRANSACTION_GAS + REMAINING_GAS + 5000;
uint32 constant DEFAULT_MIN_GAS_PRICE_GWEI = 20;
uint constant MIN_GAS_PRICE = GWEI;
uint constant MAX_GAS_PRICE = 0xffffffff * GWEI;
uint constant MAX_GAS = 4000000;
bytes8 constant VERSION = 0x0108007600aa60ef;
}
library KeysUtils {
struct Object {
uint32 gasPriceGwei;
uint32 gasLimit;
uint32 timestamp;
address contractAddress;
}
| 0 | 16,980 |
modifier CFO
function withdrawBalance(uint256 _value)
external
onlyCLevel
{
uint256 balance = address(this).balance;
require(balance >= _value);
cfoAddress.transfer(_value);
}
| 1 | 6,718 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p3d = _eth / 50;
uint256 _aff = _eth.mul(8) / 100;
uint256 _potAmount = _eth / 10;
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d);
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 0 | 19,308 |
function _unwrap(
address _owner,
uint _tokens
) private returns (bool success) {
address wethAddress = _weth();
if (_balances[wethAddress][_owner] < _tokens) {
revert('Oops! You DO NOT have enough WETH.');
}
_balances[wethAddress][_owner] =
_balances[wethAddress][_owner].sub(_tokens);
success = wethAddress.call
.gas(200000)
(abi.encodeWithSignature("withdraw(uint256)", _tokens));
if (success) {
_owner.transfer(_tokens);
emit Withdraw(
wethAddress,
_owner,
_tokens
);
} else {
revert('An error occurred while unwrapping your ETH.');
}
}
| 1 | 8,960 |
function verifyRingHasNoSubRing(Ring ring)
internal
constant
{
uint ringSize = ring.orders.length;
for (uint i = 0; i < ringSize - 1; i++) {
address tokenS = ring.orders[i].order.tokenS;
for (uint j = i + 1; j < ringSize; j++) {
ErrorLib.check(
tokenS != ring.orders[j].order.tokenS,
"found sub-ring"
);
}
}
}
| 0 | 12,679 |
function buyCore(uint256 _pID, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
core(_pID, msg.value, _affID, _eventData_);
} else {
if (_now > round_.end && round_.ended == false)
{
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit LDEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
withdrawAddr_[plyr_[_pID].addr] = 0;
}
}
| 1 | 160 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.