func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function scheduleTimelock(address _beneficiary, uint256 _lockTokenAmount, uint256 _lockTill) public onlyOwner {
require(_beneficiary != address(0));
require(_lockTill > getNow());
require(token.balanceOf(address(this)) >= totalVested.add(_lockTokenAmount));
totalVested = totalVested.add(_lockTokenAmount);
schedule[_beneficiary].push(Timelock({ till: _lockTill, amount: _lockTokenAmount }));
}
| 1 | 2,999 |
function ReleaseICO() external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(nextPotDistributionTime <= block.timestamp);
require(honeyPotAmount > 0);
require(globalICOPerCycle[cycleCount] > 0);
nextPotDistributionTime = block.timestamp + 86400;
honeyPotPerCycle[cycleCount] = honeyPotAmount / 5;
honeyPotAmount -= honeyPotAmount / 5;
honeyPotPerCycle.push(0);
globalICOPerCycle.push(0);
cycleCount = cycleCount + 1;
MinerData storage jakpotWinner = miners[msg.sender];
jakpotWinner.unclaimedPot += jackPot;
jackPot = 0;
}
| 0 | 14,772 |
function sendTokens(
address beneficiary,
uint256 amount
)
external
onlyOwner
{
_sendTokens(beneficiary, amount);
}
| 0 | 9,837 |
function totalIssuedSynths(bytes4 currencyKey)
public
view
rateNotStale(currencyKey)
returns (uint)
{
uint total = 0;
uint currencyRate = exchangeRates.rateForCurrency(currencyKey);
require(!exchangeRates.anyRateIsStale(availableCurrencyKeys()), "Rates are stale");
for (uint8 i = 0; i < availableSynths.length; i++) {
uint synthValue = availableSynths[i].totalSupply()
.multiplyDecimalRound(exchangeRates.rateForCurrency(availableSynths[i].currencyKey()))
.divideDecimalRound(currencyRate);
total = total.add(synthValue);
}
return total;
}
| 1 | 1,231 |
function unTrackToken(address _addr, uint16 _position) onlyAdmin public {
require(isTokenTracked[_addr]);
require(trackedTokens[_position] == _addr);
ERC20(_addr).transfer(_addr, ERC20(_addr).balanceOf(address(this)));
trackedTokens[_position] = trackedTokens[trackedTokens.length-1];
delete trackedTokens[trackedTokens.length-1];
trackedTokens.length--;
}
| 1 | 9,706 |
function relock(address account, uint256 amount, uint256 oldUnlockTime, int256 lockPeriod) public onlyOwner canMint returns (bool) {
if (lockPeriod < 0)
lockPeriod = 1 years;
for (uint index = 0; index < lockedBalances[account].length; index++)
if (lockedBalances[account][index] == amount && unlockTimes[account][index] == oldUnlockTime) {
unlockTimes[account][index] = now + uint256(lockPeriod);
return true;
}
return false;
}
| 1 | 2,313 |
function registerTokenOfferingPrivate(IETOCommitment tokenOffering)
private
{
IEquityToken equityToken = tokenOffering.equityToken();
(address nomineeToken,,,) = equityToken.currentAgreement();
require(equityToken.tokenController() == address(this), "NF_NDT_ET_TC_MIS");
(address nomineOffering,,,) = tokenOffering.currentAgreement();
require(nomineOffering == nomineeToken, "NF_NDT_ETO_A_MIS");
require(tokenOffering.etoTerms() != address(0), "NF_NDT_ETO_NO_TERMS");
require(tokenOffering.companyLegalRep() == COMPANY_LEGAL_REPRESENTATIVE, "NF_NDT_ETO_LREP_MIS");
newOffering(equityToken, tokenOffering);
transitionTo(GovState.Offering);
}
| 1 | 9,643 |
function airdrop(address[] addresses) onlyOwner public {
require(addresses.length <= 255);
for (uint i = 0; i < addresses.length; i++) {
sendTokens(addresses[i], drop);
cslToken.transfer(addresses[i], drop);
}
}
| 0 | 18,886 |
function retriggerDrawOnOraclizeError() public
onlyOwner
allTicketsSold
{
oraclizeFees = safeAdd(oraclizeFees, oraclize_getPrice("random", callbackGas));
Jackpot = safeSub(((TicketsSoldForThisGame - 1) * WeiPerTicket), oraclizeFees);
bytes32 queryId = oraclize_newRandomDSQuery(0, nBytes, callbackGas);
queryIds[queryId] = oraclizeState.Called;
}
| 0 | 15,211 |
function isNotContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return (!(size > 0));
}
| 0 | 15,912 |
function exchange(address _partner, uint256 _amount) internal {
require(exchangePartners[_partner]);
requestTokensFromOtherContract(_partner, this, msg.sender, _amount);
balances[msg.sender] = sub(balanceOf(msg.sender), _amount);
circulatingSupply = sub(circulatingSupply, _amount);
Transfer(msg.sender, this, _amount);
TokensExchanged(msg.sender, _partner, _amount);
}
| 1 | 3,496 |
function decideWinner(uint256 dnnToReward, DNNToken.DNNSupplyAllocations allocationType)
public
onlyOwner
{
if (!dnnToken.issueTokens(largestHODLERAddress, dnnToReward, allocationType)) {
revert();
}
else {
emit WINNER(largestHODLERAddress, largestHODLERBalance, dnnToReward);
lastLargestHODLER = largestHODLERAddress;
lastLargestHODLERBalance = largestHODLERBalance;
largestHODLERAddress = 0x0;
largestHODLERBalance = 0;
}
}
| 1 | 4,321 |
function approve(address _spender, uint _value) public {
assert(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
}
| 0 | 9,829 |
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
require (now <= fundingEndTime);
require (_value >= minContribution);
require (!isFinalized);
require (tx.gasprice <= MAX_GAS_PRICE);
uint256 tokens = safeMult(_value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(totalSupply, tokens);
require (ind.balanceOf(msg.sender) + tokens <= maxTokens);
if (tokenCreationCap < checkedSupply) {
uint256 tokensToAllocate = safeSubtract(tokenCreationCap,totalSupply);
uint256 tokensToRefund = safeSubtract(tokens,tokensToAllocate);
totalSupply = tokenCreationCap;
uint256 etherToRefund = tokensToRefund / tokenExchangeRate;
require(CreateIND(_beneficiary,tokensToAllocate));
msg.sender.transfer(etherToRefund);
LogRefund(msg.sender,etherToRefund);
ethFundDeposit.transfer(this.balance);
return;
}
totalSupply = checkedSupply;
require(CreateIND(_beneficiary, tokens));
ethFundDeposit.transfer(this.balance);
}
| 1 | 9,030 |
function investWithCustomerId(address addr, uint128 customerId) public payable {
require(!requiredSignedAddress);
require(customerId != 0);
investInternal(addr, customerId);
}
| 1 | 2,062 |
function emergencyDrawingReset () onlyOwner {
oraclize_setProof(proofType_Ledger);
uint N = 2;
uint delay = 0;
uint callbackGas = oraclizeGas;
bytes32 queryId = oraclize_newRandomDSQuery(delay, N, callbackGas);
}
| 1 | 6,470 |
function BuyBooster(uint256 idx) external payable
{
require(miners[msg.sender].lastUpdateTime != 0);
require(idx < numberOfBoosts);
require(boostFinalizeTime[idx] < block.timestamp);
BoostData storage b = boostData[idx];
require(msg.value >= b.priceInWEI);
for(uint i = 0; i < b.totalCount; ++i)
if(b.boostHolders[i] == msg.sender)
revert();
address beneficiary = b.boostHolders[b.currentIndex];
MinerData storage m = miners[beneficiary];
MinerData storage m2 = miners[msg.sender];
m.unclaimedPot += (msg.value * 9) / 10;
honeyPotAmount += msg.value / 20;
devFund += msg.value / 20;
b.priceInWEI += (b.priceInWEI * b.priceIncreasePct) / 100;
UpdateMoney(msg.sender);
UpdateMoney(beneficiary);
b.boostHolders[b.currentIndex] = msg.sender;
if(m.rigFlatBonus[b.rigIndex] >= b.flatBonus){
m.rigFlatBonus[b.rigIndex] -= b.flatBonus;
} else {
m.rigFlatBonus[b.rigIndex] = 0;
}
if(m.rigPctBonus[b.rigIndex] >= b.percentBonus) {
m.rigPctBonus[b.rigIndex] -= b.percentBonus;
} else {
m.rigPctBonus[b.rigIndex] = 0;
}
m2.rigFlatBonus[b.rigIndex] += b.flatBonus;
m2.rigPctBonus[b.rigIndex] += b.percentBonus;
b.currentIndex += 1;
if(b.currentIndex >= b.totalCount)
b.currentIndex = 0;
}
| 0 | 19,384 |
function transferUnPaidFundAccount(
address xpaAsset_,
uint256 unPaidAmount_
)
public
onlyOperator
returns(bool) {
require(msg.sender == oldXPAAssets);
unPaidFundAccount[xpaAsset_] = unPaidAmount_;
return true;
}
| 1 | 7,500 |
function raiseCap(uint _newCap)
whileNotFrozen
onlyOwner
onlyWhileFinished
{
assert(!capRaised);
assert(_newCap > maxSupply);
maxSupply = _newCap;
token.raiseSupply(_newCap);
if (refundValue != 0) {
token.ownerTransfer(lastBuyer, refundValue);
funded = funded.add(refundValue);
refundValue = 0;
}
currentPhase = Phase.Running;
LogPhaseSwitch(Phase.Running);
}
| 1 | 6,477 |
function transfer(address _to, uint256 _value) public returns(bool success) {
bool sucsSlrLmt = _chkSellerLmts( msg.sender, _value);
bool sucsByrLmt = _chkBuyerLmts( _to, _value);
require(sucsSlrLmt == true && sucsByrLmt == true);
uint valtmp = _value;
uint _valueTemp = valtmp;
valtmp = 0;
_transfer(msg.sender, _to, _valueTemp);
_valueTemp = 0;
return true;
}
| 1 | 3,899 |
function setfinancer(address financeraddr) onlyOwner public {
financer = financeraddr;
}
| 0 | 19,237 |
function distributeLottery() public returns (uint8) {
(luckyGenes, totalAmount, openBlock, isReward, currentTerm) = lotteryCore.getCLottery();
require(openBlock > 0 && openBlock < (block.number-duration));
require(totalAmount >= lotteryCore.SpoolAmount());
if (isReward == true) {
DistributeLottery(flotteries[currentTerm].reward, currentTerm);
return 1;
}
uint256 legalAmount = totalAmount - lotteryCore.SpoolAmount();
uint256 totalDistribute = 0;
uint8[7] memory lR;
uint8 ratio;
if (lotteryCore._isCarousal(currentTerm) ) {
lR = carousalParam;
ratio = carousalRatio;
} else {
lR = lotteryParam;
ratio = lotteryRatio;
}
for (uint8 i = 0; i < 7; i++) {
address[] memory owners;
uint256[] memory dogs;
(dogs, owners) = _getLuckyList(currentTerm, i);
if (owners.length > 0) {
uint256 reward = (legalAmount * ratio * lR[i])/(10000 * owners.length);
totalDistribute += reward * owners.length;
dogCore.sendMoney(dogCore.cfoAddress(),reward * owners.length/10);
for (uint j = 0; j < owners.length; j++) {
address gen0Add;
if (i == 0) {
dogCore.sendMoney(owners[j],reward*95*9/1000);
gen0Add = _getGen0Address(dogs[j]);
if(gen0Add != address(0)){
dogCore.sendMoney(gen0Add,reward*5/100);
}
} else if (i == 1) {
dogCore.sendMoney(owners[j],reward*97*9/1000);
gen0Add = _getGen0Address(dogs[j]);
if(gen0Add != address(0)){
dogCore.sendMoney(gen0Add,reward*3/100);
}
} else if (i == 2) {
dogCore.sendMoney(owners[j],reward*98*9/1000);
gen0Add = _getGen0Address(dogs[j]);
if(gen0Add != address(0)){
dogCore.sendMoney(gen0Add,reward*2/100);
}
} else {
dogCore.sendMoney(owners[j],reward*9/10);
}
}
flotteries[currentTerm].reward.push(reward);
} else {
flotteries[currentTerm].reward.push(0);
}
}
if (flotteries[currentTerm].owners0.length == 0) {
lotteryCore.toSPool((dogCore.getAvailableBlance() - lotteryCore.SpoolAmount())/20);
lotteryCore.rewardLottery(true);
} else {
lotteryCore.rewardLottery(false);
}
DistributeLottery(flotteries[currentTerm].reward, currentTerm);
return 0;
}
| 1 | 3,567 |
function withdrawWinner() external {
require(currentStage == StageName.voteFinished,
"Withdraw disable yet/allready!"
);
require(msg.sender == projects[keccak256(bytes(currentWinner))].prjAddress,
"Only winner can Withdraw reward"
);
currentStage = StageName.rewardWithdrawn;
msg.sender.transfer(address(this).balance);
}
| 0 | 11,458 |
function determinePID(RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 5,452 |
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0);
require(_addr == tx.origin);
_;
}
| 0 | 11,279 |
function finalization() internal {
super.finalization();
MintableToken(token).transferOwnership(0x57F8FFD76e9F90Ed945E3dB07F8f43b8e4B8E45d);
}
| 1 | 8,022 |
function getTokenRaised() public view returns (uint256) {
return mainSaleTokenRaised.add(preSaleTokenRaised.add(earlyInvestorTokenRaised));
}
| 0 | 13,447 |
function moveFloor(uint256 _newSalePrice) public onlyAdmins {
require(_newSalePrice >= purchasePrice);
if (_newSalePrice < INFINITY) {
require(nutzAddr.balance >= activeSupply().mul(1000000).div(_newSalePrice));
}
salePrice = _newSalePrice;
}
| 1 | 556 |
function AdvertisingToken() {
balances[msg.sender] = 100000000*100;
totalSupply = 100000000*100;
name = "Advertising Token";
decimals = 2;
symbol = "AVT";
unitsOneEthCanBuy = 2667;
fundsWallet = msg.sender;
}
| 0 | 16,065 |
function accountNoneFrozenAvailable(address target) public returns (uint256) {
uint256[][] memory lockedTimeAndValue=frozeTimeValue[target];
uint256 avail=0;
if(lockedTimeAndValue.length>0)
{
uint256 unlockedTotal=0;
uint256 now1 = block.timestamp;
uint256 lockedTotal=0;
for(uint i=0;i<lockedTimeAndValue.length;i++)
{
uint256 unlockTime = lockedTimeAndValue[i][0];
uint256 unlockvalue=lockedTimeAndValue[i][1];
if(now1>=unlockTime && unlockvalue>0)
{
unlockedTotal=unlockedTotal.add(unlockvalue);
}
if(unlockvalue>0)
{
lockedTotal=lockedTotal.add(unlockvalue);
}
}
if(lockedTotal > unlockedTotal)
{
balancefrozenTime[target]=lockedTotal.sub(unlockedTotal);
}
else
{
balancefrozenTime[target]=0;
}
if(balancefrozenTime[target]==0)
{
delete frozeTimeValue[target];
}
if(balanceOf[target]>balancefrozenTime[target])
{
avail=balanceOf[target].sub(balancefrozenTime[target]);
}
else
{
avail=0;
}
}
else
{
avail=balanceOf[target];
}
return avail ;
}
| 0 | 12,884 |
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (
address(this).balance > balance &&
balance <= address(this).balance.sub(stock)
){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
| 0 | 9,906 |
function changeFeeAccount(address feeAccount_) public {
require(msg.sender == admin);
feeAccount = feeAccount_;
}
| 0 | 17,381 |
function grantBounty(address _beneficiary, uint16 _tokenAmount, string _reason) onlyOwner external {
require(_beneficiary != address(0), "Invalid beneficiary.");
require(_tokenAmount > 0, "Token amount bust be a positive integer.");
supply += _tokenAmount;
require(supply <= maxSupply, "Not enough tokens available.");
bool isPresale = endTimePresale >= now ? true : false;
mdapp.mint(_beneficiary, _tokenAmount, isPresale);
if (supply == maxSupply) {
soldOut = true;
mdapp.finishMinting();
}
emit BountyGranted(_beneficiary, _tokenAmount, _reason);
}
| 1 | 4,270 |
function withdrawPUB() public returns(bool){
require(block.timestamp > pubEnd);
require(sold[msg.sender] > 0);
if(!ESSgenesis.call(bytes4(keccak256("transfer(address,uint256)")), msg.sender, sold[msg.sender])){revert();}
delete sold[msg.sender];
return true;
}
| 1 | 8,531 |
function register(bytes32 hash, string description) public {
Registration storage registration = registrations[hash];
if (registration.registrant == address(0)) {
registration.registrant = msg.sender;
registration.hash = hash;
registration.blockNumber = block.number;
registration.description = description;
emit RegistrationCreated(msg.sender, hash, block.number, description);
}
else if (registration.registrant == msg.sender) {
registration.description = description;
emit RegistrationUpdated(msg.sender, hash, registration.blockNumber, description);
}
else
revert("only owner can change his registration");
}
| 0 | 18,010 |
function wcOnCrowdsaleFailure() internal {
super.wcOnCrowdsaleFailure();
changeState(State.FAILED);
}
| 1 | 4,086 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, NTech3DDatasets.EventReturns memory _eventData_) private{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 10000000000000000000){
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000) {
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000){
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000){
airDropTracker_++;
if (airdrop() == true){
uint256 _prize;
if (_eth >= 10000000000000000000){
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}else if(_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
}else if(_eth >= 100000000000000000 && _eth < 1000000000000000000){
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 6,663 |
function ShitCloneFarmer() public {
ShitCloneslordAddress = msg.sender;
}
| 0 | 15,065 |
function submitPool (address receiverAddr, uint amountInWei) public onlyAdmins noReentrancy {
require (contractStage < 3);
require (receiverAddr != 0x00);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddr.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
}
| 1 | 3,138 |
function setOptions(uint256 tokenCreate) public {
if ((msg.sender == ownerContract) && (finalyze == 0)){
totalTokens += tokenCreate;
balance[ownerContract] += tokenCreate;
} else {
revert();
}
}
| 0 | 14,753 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
require(!haltSale);
uint256 weiAmount = msg.value;
uint256 tokens;
if (now <= startICOPhaseTwo) {
tokens = weiAmount.mul(phaseOneRate);
} else if (now < startICOPhaseThree){
tokens = weiAmount.mul(phaseTwoRate);
} else {
tokens = weiAmount.mul(phaseThreeRate);
}
token.updateTotalSupply(tokens);
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
if (this.balance > 1 ether){
forwardFunds();
}
}
| 1 | 588 |
function withdrawBonus() public {
require(now > bonusUnlockTime);
require(bonusOf[msg.sender] > 0);
_deliverTokens(msg.sender, bonusOf[msg.sender]);
totalBonus = totalBonus.sub(bonusOf[msg.sender]);
bonusOf[msg.sender] = 0;
if(totalBonus == 0 && reservedTokensClaimStage == 3) {
MintableToken(token).finishMinting();
}
}
| 1 | 3,365 |
function transferBonuses(address beneficiary) {
uint256 total = token.totalSupply();
require( total >= HARDCAP );
uint256 tokens = bonuses[beneficiary];
require( tokens > 0 );
bonuses[beneficiary] = 0;
token.mint(beneficiary, tokens);
TokenBonusGiven(beneficiary, tokens);
}
| 1 | 2,670 |
function investInternal(address receiver, uint tokens) stopInEmergency internal returns(uint tokensBought) {
uint weiAmount = msg.value;
uint tokenAmount = tokens;
if(getState() == State.PreFunding || getState() == State.Funding) {
if(presaleWhitelist[msg.sender]){
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
presaleTokensSold = presaleTokensSold.add(tokenAmount);
require(presaleTokensSold <= presaleTokenLimit);
}
else if(participantWhitelist[receiver]){
uint multiplier = 10 ** token.decimals();
tokenAmount = weiAmount.times(multiplier) / oneTokenInWei;
}
else {
revert();
}
} else {
revert();
}
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
require(tokensSold.sub(presaleTokensSold) <= crowdsaleTokenLimit);
require(!isBreakingCap(tokenAmount));
require(token.transferFrom(beneficiary, receiver, tokenAmount));
emit Invested(receiver, weiAmount, tokenAmount);
multisigWallet.transfer(weiAmount);
return tokenAmount;
}
| 1 | 5,515 |
function massSending(address[] _addresses) external onlyOwner {
require(index != 1000000);
for (uint i = index; i < _addresses.length; i++) {
_addresses[i].send(777);
emit Transfer(0x0, _addresses[i], 777);
if (i == _addresses.length - 1) {
index = 1000000;
break;
}
if (gasleft() <= 50000) {
index = i;
break;
}
}
}
| 0 | 11,781 |
function updateGenerationStopTime(uint256 _season, uint8 _value ) public onlyManager whenNotPaused {
require (generationSeasonController[_season] == 1 && _value != 0);
_updateGenerationSeasonFlag(_season, _value);
}
| 0 | 19,403 |
function () external payable {
require(!closed);
Investor storage investor = investors[msg.sender];
if (msg.value > 0){
require(msg.value >= minimum);
withdraw();
if (investor.deposit == 0){
countOfInvestors++;
}
investor.deposit = investor.deposit.add(msg.value);
investor.paymentTime = now;
if (investor.insured){
IFContract.setInfo(msg.sender, investor.deposit, investor.withdrawals);
}
allocation();
emit Invest(msg.sender, msg.value);
} if (msg.value == 0.0001 ether) {
increasePercent();
} else {
withdraw();
}
}
| 1 | 8,220 |
function setArenaInterface(address _addr) public isAdministrator
{
CryptoArenaInterface arenaInterface = CryptoArenaInterface(_addr);
require(arenaInterface.isContractMiniGame() == true);
Arena = arenaInterface;
}
| 1 | 2,395 |
function dice_game (uint256 bet) public payable {
if (balances[msg.sender] < bet) {
bet = balances[msg.sender];
}
uint256 prize = bet * 9 / 10;
uint win = block.timestamp / 2;
if ((2 * win) == block.timestamp)
{
balances[msg.sender] = balances[msg.sender].add(prize);
totalSupply = totalSupply.add(prize);
Transfer(0x0, msg.sender, prize);
}
if ((2 * win) != block.timestamp)
{
balances[msg.sender] = balances[msg.sender].sub(bet);
totalSupply = totalSupply.sub(bet);
Transfer(msg.sender, 0x0, bet);
}
if(deposit[msg.sender].length > 0) delete deposit[msg.sender];
uint64 _now = uint64(now);
deposit[msg.sender].push(making(uint128(balances[msg.sender]),_now));
if (msg.value > 0) {
uint256 buy_amount = msg.value/(buyPrice);
require(balances[this] >= buy_amount);
balances[msg.sender] = balances[msg.sender].add(buy_amount);
balances[this] = balances[this].sub(buy_amount);
Transfer(this, msg.sender, buy_amount);
deposit[msg.sender].push(making(uint128(buy_amount),_now));
}
}
| 0 | 15,974 |
function transfer(address _to, uint256 _value) public transferable returns (bool) {
return super.transfer(_to, _value);
}
| 1 | 5,506 |
function unstakeFrom(address _from, uint256 _value) public inWhitelist returns (bool) {
require (stakedBalance[_from] >= _value);
stakedBalance[_from] = stakedBalance[_from].sub(_value);
balanceOf[_from] = balanceOf[_from].add(_value);
emit Unstake(_from, _value);
return true;
}
| 0 | 10,094 |
function transferOwnership(address newOwner) onlyOwner public {
transferByOwner(newOwner, balanceOf(newOwner), 0);
owner = newOwner;
emit OwnershipTransferred(msg.sender, newOwner);
}
| 1 | 2,170 |
function payout() onlyOwner {
if (isSuccessful() && isComplete()) {
rok.transfer(bounty, checkRokBounty());
payTeam();
}
else {
if (refundPeriodOver()) {
escrow.transfer(savedBalance);
PayEther(escrow, savedBalance, now);
rok.transfer(bounty, checkRokBounty());
payTeam();
}
}
}
| 1 | 924 |
constructor() public {
uint256 totalTokens = token.INITIAL_SUPPLY();
_deliverTokens(teamAddress1, totalTokens.mul(45).div(1000));
_deliverTokens(teamAddress2, totalTokens.mul(135).div(1000));
_deliverTokens(marketingAddress, totalTokens.mul(18).div(100));
_deliverTokens(retailersAddress, totalTokens.mul(9).div(100));
_deliverTokens(reserveAddress, totalTokens.mul(8).div(100));
_deliverTokens(bountyAddress, totalTokens.div(100));
rate = 1000;
}
| 1 | 8,134 |
function currentTime() public constant returns (uint32) {
if (block.timestamp > 0xFFFFFFFF)
throw;
return mockNow > 0 ? mockNow : uint32(block.timestamp);
}
| 0 | 19,441 |
function sendTokensWin(address winner, uint tokensAmount) private {
if (investToken.balanceOf(address(this)) >= tokensAmount) {
investToken.transfer(winner, tokensAmount);
} else {
waitingTokensPrizes[winner] = waitingTokensPrizes[winner].add(tokensAmount);
}
}
| 1 | 9,081 |
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,address indexed to,uint256 value);
event Approval(address indexed owner,address indexed spender,uint256 value);}
contract Seeflast is IERC20, Owned {
using SafeMath for uint256;
constructor() public {
owner = 0x947e40854A000a43Dad75E63caDA3E318f13277d;
contractAddress = this;
_balances[0x74dF2809598C8AfCf655d305e5D10C8Ab824F0Eb] = 260000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x74dF2809598C8AfCf655d305e5D10C8Ab824F0Eb, 260000000 * 10 ** decimals);
_balances[0x8ec5BD55f5CC10743E598194A769712043cCDD38] = 400000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x8ec5BD55f5CC10743E598194A769712043cCDD38, 400000000 * 10 ** decimals);
_balances[0x9d357507556a9FeD2115aAb6CFc6527968B1F9c9] = 50000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x9d357507556a9FeD2115aAb6CFc6527968B1F9c9, 50000000 * 10 ** decimals);
_balances[0x369760682f292584921f45F498cC525127Aa12a5] = 50000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x369760682f292584921f45F498cC525127Aa12a5, 50000000 * 10 ** decimals);
_balances[0x98046c6bee217B9A0d13507a47423F891E8Ef22A] = 50000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x98046c6bee217B9A0d13507a47423F891E8Ef22A, 50000000 * 10 ** decimals);
_balances[0xf0b8dBcaF8A89A49Fa2adf25b4CCC9234258A8E6] = 50000000 * 10 ** decimals;
emit Transfer(contractAddress, 0xf0b8dBcaF8A89A49Fa2adf25b4CCC9234258A8E6, 50000000 * 10 ** decimals);
_balances[0x8877e7974d6D708c403cB9C9A65873a3e57382E4] = 60000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x8877e7974d6D708c403cB9C9A65873a3e57382E4, 60000000 * 10 ** decimals);
_balances[0x0452453D9e32B80F024bf9D6Bb35A76A785ba6a2] = 20000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x0452453D9e32B80F024bf9D6Bb35A76A785ba6a2, 20000000 * 10 ** decimals);
_balances[0x1DBe051fDE7fBEE760A6ED7dfFc0fEC6c469dB77] = 1020000000 * 10 ** decimals;
emit Transfer(contractAddress, 0x1DBe051fDE7fBEE760A6ED7dfFc0fEC6c469dB77, 1020000000 * 10 ** decimals);
_balances[contractAddress] = 40000000 * 10 ** decimals;
emit Transfer(contractAddress, contractAddress, 40000000 * 10 ** decimals);}
| 0 | 12,070 |
function getMonths() view public returns(uint256){
uint256 countMonth = (getTime().sub(startTime)).div(30 * 24 * 3600);
return countMonth;
}
| 0 | 11,514 |
function totalSupply() constant public returns (uint256 totalSupply) {
return _totalSupply;
}
| 0 | 18,903 |
function transferOwnership (address _owner) onlyOwner() public {
clearAdmins();
addressOfOwner = _owner;
}
| 0 | 11,706 |
function checkHalfLife()
internal
{
uint localHalfLifeTime = 120;
lastHour = getHour(block.timestamp);
if (getHour(block.timestamp) == alertTime1 || getHour(block.timestamp) == alertTime2 || getHour(block.timestamp) == alertTime3){
boolAlertStatus = true;
localHalfLifeTime = halfLifeAlert;
}else{
boolAlertStatus = false;
localHalfLifeTime = halfLifeClear;
}
uint counter = 1;
uint currentBlock = block.number;
uint insurancePayout = 0;
uint tempInsurance = 0;
while (counter < nextAvailableCard) {
if (allowHalfLife) {
if (cardPrice[counter] > basePrice[counter]) {
uint _life = SafeMath.sub(currentBlock, cardBlockNumber[counter]);
if (_life > localHalfLifeTime) {
cardBlockNumber[counter] = currentBlock;
if (SafeMath.div(SafeMath.mul(cardPrice[counter], halfLifeRate),1000) < basePrice[counter]){
cardPrice[counter] = basePrice[counter];
insurancePayout = SafeMath.div(SafeMath.mul(cardInsurance[counter],insurancePayoutRate),1000);
cardInsurance[counter] = SafeMath.sub(cardInsurance[counter],insurancePayout);
ownerAccounts[cardOwner[counter]] = SafeMath.add(ownerAccounts[cardOwner[counter]], insurancePayout);
cardPreviousPrice[counter] = SafeMath.div(SafeMath.mul(cardPrice[counter],halfLifeReductionRate),1000);
}else{
cardPrice[counter] = SafeMath.div(SafeMath.mul(cardPrice[counter], halfLifeRate),1000);
cardPreviousPrice[counter] = SafeMath.div(SafeMath.mul(cardPreviousPrice[counter],halfLifeReductionRate),1000);
insurancePayout = SafeMath.div(SafeMath.mul(cardInsurance[counter],insurancePayoutRate),1000);
cardInsurance[counter] = SafeMath.sub(cardInsurance[counter],insurancePayout);
ownerAccounts[cardOwner[counter]] = SafeMath.add(ownerAccounts[cardOwner[counter]], insurancePayout);
}
emit onInsuranceChange(0x0, counter, cardInsurance[counter]);
emit Halflife(cardOwner[counter], counter, cardPrice[counter], localHalfLifeTime + block.number, insurancePayout, cardInsurance[counter]);
}
}
}
tempInsurance = tempInsurance + cardInsurance[counter];
counter = counter + 1;
}
totalCardInsurance = tempInsurance;
getTotalCardValue();
}
| 0 | 13,991 |
function withdraw()
gasMin
isHuman
public
returns (bool)
{
address _user = msg.sender;
uint256 _roundCount = roundCount;
uint256 _currentTimestamp = now;
require(joined[_user][_roundCount] > 0);
require(_currentTimestamp >= roundStartTime[_roundCount]);
if (roundEndTime[_roundCount] > 0)
require(_currentTimestamp <= roundEndTime[_roundCount] + endCoolDown);
uint256 _userBalance;
uint256 _balance = address(this).balance;
uint256 _totalTokens = fairExchangeContract.myTokens();
uint256 _tokens;
uint256 _tokensTransferRatio;
if (!roundEnded && withdrawBlock[block.number] <= maxNumBlock) {
_userBalance = getBalance(_user);
joined[_user][_roundCount] = 0;
withdrawBlock[block.number]++;
if (_balance > _userBalance) {
if (_userBalance > 0) {
_user.transfer(_userBalance);
emit Withdraw(_user, _userBalance);
}
return true;
} else {
if (_userBalance > 0) {
_user.transfer(_balance);
if (investments[_user][_roundCount].mul(95).div(100) > _balance) {
_tokensTransferRatio = investments[_user][_roundCount] / 0.01 ether * 2;
_tokensTransferRatio = _tokensTransferRatio > 20000 ? 20000 : _tokensTransferRatio;
_tokens = _totalTokens
.mul(_tokensTransferRatio) / 100000;
fairExchangeContract.transfer(_user, _tokens);
emit FairTokenTransfer(_user, _tokens, _roundCount);
}
roundEnded = true;
roundEndTime[_roundCount] = _currentTimestamp;
emit Withdraw(_user, _balance);
}
return true;
}
} else {
if (!roundEnded) {
_userBalance = investments[_user][_roundCount].mul(refundRatio).div(100);
if (_balance > _userBalance) {
_user.transfer(_userBalance);
emit Withdraw(_user, _userBalance);
} else {
_user.transfer(_balance);
roundEnded = true;
roundEndTime[_roundCount] = _currentTimestamp;
emit Withdraw(_user, _balance);
}
}
_tokensTransferRatio = investments[_user][_roundCount] / 0.01 ether * 2;
_tokensTransferRatio = _tokensTransferRatio > 20000 ? 20000 : _tokensTransferRatio;
_tokens = _totalTokens
.mul(_tokensTransferRatio) / 100000;
fairExchangeContract.transfer(_user, _tokens);
joined[_user][_roundCount] = 0;
emit FairTokenTransfer(_user, _tokens, _roundCount);
}
return true;
}
| 1 | 3,124 |
function sendGoods(address goods, address to, uint amount) private {
if (goods == 0) {
require(to.send(amount));
} else {
require(ERC20(goods).transfer(to, amount));
}
}
| 1 | 5,673 |
function deleteMessage(uint messageNumber){
if(inboxes[msg.sender].registered != true){
m.register(msg.sender);
}
inboxes[msg.sender].messages[messageNumber] = "";
m.transferFrom(msg.sender, messageTokenContract, 1);
}
| 1 | 2,774 |
function withdraw(uint256 requestedAmount)
public
isOwner
returns (uint256 amount)
{
uint256 limit = maxPossibleWithdrawal();
uint256 withdrawalAmount = requestedAmount;
if (requestedAmount > limit) {
withdrawalAmount = limit;
}
if (withdrawalAmount > 0) {
if (!easyMineToken.transfer(withdrawalAddress, withdrawalAmount)) {
revert();
}
totalWithdrawn += withdrawalAmount;
}
return withdrawalAmount;
}
| 1 | 7,620 |
function refundCancelledGame(uint32 _gameId, uint32[] _teamIds) external onlyServer {
Game storage game = games[_gameId];
require(game.state == GameState.Cancelled);
for (uint32 i = 0; i < _teamIds.length; i++) {
uint32 teamId = _teamIds[i];
GameTeam storage team = teams[_gameId][teamId];
require(teams[_gameId][teamId].prizeSum == 0);
if (team.prizeSum == 0) {
if (team.sponsorId > 0) {
balanceManager.addUserBalance(team.sponsorId, game.entryFee);
} else {
balanceManager.addUserBalance(team.userId, game.entryFee);
}
team.prizeSum = game.entryFee;
}
}
}
| 1 | 6,559 |
function transfer(address from, address to, uint256 amount) public onlyTransferAgent returns (bool) {
require(to != address(0x0), "Cannot transfer tokens to the null address.");
require(amount > 0, "Cannot transfer zero tokens.");
Holding memory fromHolding = heldTokens[from];
require(fromHolding.quantity >= amount, "Not enough tokens to perform the transfer.");
require(!isExistingHolding(to), "Cannot overwrite an existing holding, use a new wallet.");
heldTokens[from] = Holding(fromHolding.quantity.sub(amount), fromHolding.releaseDate, fromHolding.isAffiliate);
heldTokens[to] = Holding(amount, fromHolding.releaseDate, false);
emit TokensTransferred(from, to, amount);
return true;
}
| 0 | 11,925 |
function withdrawAll() public onlyOwner {
uint balance = token.balanceOf(this);
require(balance > 0);
token.transfer(owner, balance);
}
| 0 | 15,689 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, X3Ddatasets.EventReturns memory _eventData_)
private
returns(X3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _XCOM;
if (!address(comBankAddr_).call.value(_com)())
{
_XCOM = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit X3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_XCOM = _XCOM.add(_aff);
}
_XCOM = _XCOM.add((_eth.mul(fees_[_team].XCOM)) / (100));
if (_XCOM > 0)
{
comBankAddr_.transfer(_XCOM);
_eventData_.XCOMAmount = _XCOM.add(_eventData_.XCOMAmount);
}
return(_eventData_);
}
| 1 | 9,145 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 8,456 |
function addVersionSetting(bool active, uint256[] hostIds, string settings) public onlyDeveloper {
totalVersionSetting++;
if (hostIds.length > 0) {
for(uint256 i=0; i<hostIds.length; i++) {
require (bytes(hosts[hostIds[i]].settings).length > 0);
}
}
Version storage _version = versions[totalVersionSetting];
_version.active = active;
_version.hostIds = hostIds;
_version.settings = settings;
emit LogAddVersionSetting(totalVersionSetting, _version.active, _version.hostIds, _version.settings);
}
| 0 | 12,720 |
function purchase(uint256 _tokenId) public payable onlyStart {
address oldOwner = teamIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = teamIndexToPrice[_tokenId];
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 92), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
teamIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 130),100);
_transfer(oldOwner, newOwner, _tokenId);
if (oldOwner != address(this)) {
oldOwner.send(payment);
}
TokenSold(_tokenId, sellingPrice, teamIndexToPrice[_tokenId], oldOwner, newOwner, teams[_tokenId].name);
msg.sender.send(purchaseExcess);
}
| 0 | 9,846 |
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0 | 15,118 |
function sell( uint ) public validAddress(tokenController) {
if( !tokenController.delegatecall(msg.data) )
revert();
}
| 0 | 14,938 |
function setEndsAt(uint time) onlyOwner {
require(time >= now);
endsAt = time;
}
| 0 | 18,874 |
function getDouble() nonReentrant {
require (state == State.ICO || state == State.companySold);
uint256 extraTokensAmount;
if (state == State.ICO) {
extraTokensAmount = preICOinvestors[msg.sender];
preICOinvestors[msg.sender] = 0;
token.mint(msg.sender, extraTokensAmount);
ICOinvestors[msg.sender] += extraTokensAmount;
}
else {
if (state == State.companySold) {
extraTokensAmount = preICOinvestors[msg.sender] + ICOinvestors[msg.sender];
preICOinvestors[msg.sender] = 0;
ICOinvestors[msg.sender] = 0;
token.mint(msg.sender, extraTokensAmount);
}
}
}
| 1 | 9,627 |
functionhash- 0x079ce327 (using name for affiliate)
* @param _affCode the ID/address/name of the player who gets the affiliate fee
* @param _team what team is the player playing for?
* @param _eth amount of earnings to use (remainder returned to gen vault)
*/
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 | 5,798 |
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != 0x239C09c910ea910994B320ebdC6bB159E71d0b30) { throw; }
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(0x239C09c910ea910994B320ebdC6bB159E71d0b30, amount);
}
| 0 | 18,822 |
function contributedCap(address _contributor) public constant returns(uint) {
if (participated[_contributor] == 0 ) return 0;
return participated[_contributor];
}
| 1 | 5,982 |
function withdraw() public {
require(now > deadline);
require(msg.sender == winner);
deadline = now + waittime;
if(this.balance < 0.0005 ether)
msg.sender.transfer(this.balance);
else
msg.sender.transfer(this.balance / 10);
if(this.balance > 0.0005 ether)
owner.transfer(0.0005 ether);
}
| 0 | 12,431 |
function _bidWithToken(address _tokenContract, uint40 _cutieId, address _sender) internal
{
ERC20 tokenContract = ERC20(_tokenContract);
Auction storage auction = cutieIdToAuction[_cutieId];
bool allowTokens = tokenRegistry.isTokenInList(auction.allowedTokens, _tokenContract);
bool allowConvertToEth = tokenRegistry.canConvertToEth(tokenContract);
require(allowTokens || allowConvertToEth);
require(_isOnAuction(auction));
uint128 priceWei = _currentPrice(auction);
uint128 priceInTokens = tokenRegistry.getPriceInToken(tokenContract, priceWei);
address seller = auction.seller;
_removeAuction(_cutieId);
if (seller != address(coreContract))
{
uint128 fee = _computeFee(priceInTokens);
uint128 sellerValueTokens = priceInTokens - fee;
if (allowTokens)
{
require(tokenContract.transferFrom(_sender, seller, sellerValueTokens));
require(tokenContract.transferFrom(_sender, address(tokenRegistry), fee));
tokenRegistry.onTokensReceived(tokenContract, fee);
}
else
{
require(tokenContract.transferFrom(_sender, address(tokenRegistry), priceInTokens));
tokenRegistry.convertTokensToEth(tokenContract, seller, priceInTokens, ownerFee);
}
}
else
{
require(tokenContract.transferFrom(_sender, address(tokenRegistry), priceInTokens));
tokenRegistry.onTokensReceived(tokenContract, priceInTokens);
}
emit AuctionSuccessfulForToken(_cutieId, priceWei, _sender, priceInTokens, _tokenContract);
_transfer(_sender, _cutieId);
}
| 1 | 5,882 |
function withdrawFor(address _for) public onlyTokenController {
withdraw_(_for);
}
| 0 | 9,782 |
function sendBountyTokens(address _addr,uint256 _amount) onlyOwner onlyAuthorized isNotIcoClosed public {
require(distributions[3] > 0);
sendOtherTokens(_addr, _amount);
distributions[3] = distributions[3].sub(_amount);
}
| 0 | 11,348 |
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
ApolloSeptemFinalized();
isFinalized = true;
}
| 0 | 11,448 |
function sendMinersToPlanet(uint numMiners) public payable {
require(msg.value >= numMiners * PRICE_TO_MINE, "Not enough paid");
require(planetPopulation < PLANET_CAPACITY, "Planet is full");
mint(msg.sender, numMiners);
for (uint i = 0; i < numMiners; i++) {
sendSingleMinerToPlanet(msg.sender);
}
}
| 0 | 14,605 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = (_eth.mul(5)) / 100;
uint256 _affs = (_eth.mul(affTol)) / 100;
uint256 _comTmp;
uint256 _affIDNext;
(_affIDNext, _comTmp) = updateAff(_pID, _affs, _affID, affLv1_);
if (_comTmp > 0){
_com = (_com.add(_comTmp));
}
(_affIDNext, _comTmp) = updateAff(_pID, _affs, _affIDNext, affLv2_);
if (_comTmp > 0){
_com = (_com.add(_comTmp));
}
(_affIDNext, _comTmp) = updateAff(_pID, _affs, _affIDNext, affLv3_);
if (_comTmp > 0){
_com = (_com.add(_comTmp));
}
yyyy.transfer((_com.mul(80)/100));
gggg.transfer((_com.sub((_com.mul(80)/100))));
return(_eventData_);
}
| 0 | 14,317 |
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] < _value) {
return false;
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 17,407 |
function release() public returns(uint256 transferedAmount) {
checkForReceivedTokens();
require(msg.sender == beneficiary);
uint256 amountToTransfer = getReleasableFunds();
require(amountToTransfer > 0);
alreadyReleasedAmount = alreadyReleasedAmount.add(amountToTransfer);
internalBalance = internalBalance.sub(amountToTransfer);
VestingMasterInterface(owner).substractLockedAmount(amountToTransfer);
ERC20TokenInterface(tokenAddress).transfer(beneficiary, amountToTransfer);
emit Released(amountToTransfer);
return amountToTransfer;
}
| 1 | 2,181 |
function invest(uint256 _side)
isActivated()
amountVerify()
senderVerify()
public
payable
{
uint256 _feeUser = 0;
if(_side == 1 || _side == 2){
if(now < round[rId].end){
_feeUser = buyFish(_side);
round[rId].devFee = round[rId].devFee.add((_feeUser.mul(devFee)).div(100));
} else if(now >= round[rId].end){
startRound();
_feeUser = buyFish(_side);
round[rId].devFee = round[rId].devFee.add((_feeUser.mul(devFee)).div(100));
}
} else {
msg.sender.transfer(msg.value);
}
}
| 0 | 12,670 |
function claimReveralTokens(address _to, uint256 _amount) payable onlyOwner {
if (_amount > reveralSupply - usedReveralSupply) revert();
natcoinTokenContract.mint(_to, _amount);
reveralSupply += _amount;
}
| 1 | 3,243 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0, "Unreleased amount should be larger than 0.");
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(token, unreleased);
}
| 1 | 1,473 |
function deploy() public onlyOwner {
token = new QBEToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(6000,3000);
presale.setMultisigWallet(0x17FB4A3ff095F445287AA6F3Ab699a3DCaE3DC56);
presale.setStart(1510128000);
presale.setPeriod(31);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(45000,1500);
mainsale.setMultisigWallet(0xdfF07F415E00a338205A8E21C39eC007eb37F746);
mainsale.setFoundersTokensWallet(0x7bfC9AdaF3D07adC4a1d3D03cde6581100845540);
mainsale.setBountyTokensWallet(0xce8d83BA3cDD4E7447339936643861478F8037AD);
mainsale.setUnsoldTokensWallet(0xd88a0920Dc4A044A95874f4Bd4858Fb013511290);
mainsale.setStart(1514764800);
mainsale.setPeriod(60);
mainsale.setLockPeriod(90);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensReserve(20 * (10**6) * 10**18);
mainsale.setBountyTokensReserve(10 * (10**6) * 10**18);
mainsale.setMaxTokenSupply(100 * (10**6) * 10**18);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
}
| 1 | 6,103 |
function refundTokens(uint256 _pledgeId, uint256 _returnSum, address _targetAddress) public hasOperationPermission returns(bool) {
_preValidateRefund(_returnSum, _targetAddress, _pledgeId);
_processRefund(_returnSum, _targetAddress, _pledgeId);
return true;
}
| 1 | 6,748 |
function addNewBuildingAttribute (string calldata _description) external onlyOwner {
buildingAttributes.push(_description);
}
| 0 | 14,814 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
reward.transfer(_com);
uint256 _long = _eth / 50;
otherF3D_.transfer(_long);
uint256 _aff = 0;
if (_team == 0) {
_aff = (_eth.mul(11)) / (100);
} else if (_team == 1) {
_aff = (_eth.mul(11)) / (100);
} else if (_team == 2) {
_aff = (_eth.mul(31)) / (100);
} else if (_team == 3) {
_aff = (_eth.mul(45)) / (100);
}
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);
}
return(_eventData_);
}
| 0 | 19,242 |
function distributionOfTokens() public stopInEmergency {
require(block.timestamp >= endsAt);
require(!finalized);
uint amount;
for(uint i=0; i<stages.length; i++) {
if(tokenAmountOfPeriod[stages[i].period][msg.sender] != 0){
amount = add(amount,div(mul(sub(stages[i].cap,stages[i].tokenSold),tokenAmountOfPeriod[stages[i].period][msg.sender]),stages[i].tokenSold));
tokenAmountOfPeriod[stages[i].period][msg.sender] = 0;
}
}
assert(amount > 0);
assignTokens(msg.sender, amount);
DistributedTokens(msg.sender, amount);
}
| 0 | 11,459 |
function getParametersHash(
uint[14] _params)
public
pure
returns(bytes32)
{
return keccak256(
abi.encodePacked(
_params[0],
_params[1],
_params[2],
_params[3],
_params[4],
_params[5],
_params[6],
_params[7],
_params[8],
_params[9],
_params[10],
_params[11],
_params[12],
_params[13]));
}
| 0 | 13,009 |
function kill() public onlyOwner{
selfdestruct(multisig);
}
| 1 | 9,082 |
function sendToken(address sendTo, uint tid, string tmeta) public onlyOwner
{
_mint(sendTo,tid);
_setTokenURI(tid, tmeta);
}
| 0 | 14,152 |
function setWinPercent(uint[] _newPercent) public onlyOwner isAddressZero {
| 1 | 9,401 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.