func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function getStakeTokens(address _address, uint _year, uint _month) public view returns (uint256 _amount) {
validateMonth(_year, _month);
require(stakesLockups[_address] < now);
_amount = 0;
if(stakesLockups[_address] < now && totalStakes[_year][_month] > 0){
uint256 _tmpStake = stakeTmpBalance[_year][_month][_address];
if(_tmpStake > 0){
uint256 _totalStakesBal = stakeBalance[_address];
uint256 _totalStakes = totalStakes[_year][_month];
uint256 _poolAmount = poolBalance[_year][_month];
_amount = ((_tmpStake.mul(_poolAmount)).mul(50)).div(_totalStakes.mul(100));
_amount = _amount.add(_totalStakesBal);
}
}
} | 0 | 2,642 |
function notarize(string sha256) {
if ( bytes(sha256).length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 | 1,497 |
function hatchEgg() isActive external {
EtheremonTransformData transformData = EtheremonTransformData(transformDataContract);
MonsterEgg memory egg;
(egg.eggId, egg.objId, egg.classId, egg.trainer, egg.hatchTime, egg.newObjId) = transformData.getHatchingEggData(msg.sender);
if (egg.eggId == 0 || egg.trainer != msg.sender)
revert();
if (egg.newObjId > 0 || egg.hatchTime > block.timestamp) {
revert();
}
EtheremonMonsterNFTInterface monsterNFT = EtheremonMonsterNFTInterface(monsterNFTContract);
uint objId = monsterNFT.mintMonster(egg.classId, egg.trainer, "..name me...");
transformData.setHatchedEgg(egg.eggId, uint64(objId));
EventHatchEgg(egg.trainer, egg.eggId, objId);
} | 1 | 449 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
State state = getState();
if (state == State.Funding) {
} else if (state == State.PreFunding) {
if (!earlyParticipantWhitelist[receiver]) {
throw;
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if (tokenAmount == 0) {
throw;
}
if (investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver], weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver], tokenAmount);
uint256 personalWeiLimit = smallCapLimitOf[receiver];
if (block.timestamp > startsAt + largeCapDelay) {
personalWeiLimit = safeAdd(personalWeiLimit, largeCapLimitOf[receiver]);
}
if (investedAmountOf[receiver] > personalWeiLimit) {
throw;
}
weiRaised = safeAdd(weiRaised, weiAmount);
tokensSold = safeAdd(tokensSold, tokenAmount);
if (isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if (!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
} | 1 | 321 |
function balanceOfUnclaimed(address player) public constant returns (uint256) {
uint256 lSave = lastJadeSaveTime[player];
if (lSave > 0 && lSave < block.timestamp) {
return SafeMath.mul(getJadeProduction(player),SafeMath.div(SafeMath.sub(block.timestamp,lSave),60));
}
return 0;
} | 1 | 1,211 |
function
* from the KYCBase contract.
* @param to The address that will receive the minted tokens.
* @param amount The amount of tokens to mint.
*/
function mintTokens(address to, uint256 amount) private {
token.mint(to, amount);
} | 1 | 1,747 |
function startNextDepositBatch() public {
callExternal(depositor);
} | 0 | 4,650 |
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 50 ether) {
return 1.5 ether;
} else if (totalInvested <= 150 ether) {
return 3 ether;
} else if (totalInvested <= 300 ether) {
return 5 ether;
} else if (totalInvested <= 500 ether) {
return 7 ether;
} else {
return 10 ether;
}
} | 0 | 3,554 |
function ManUvsTottenham() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 0 | 4,957 |
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_);
} | 1 | 2,057 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
isGasLimit()
public
payable
{
J3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
} | 0 | 3,631 |
function addToVestMap(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _torelease
) public onlyOwner{
require(_beneficiary != address(0));
require(_cliff <= _duration);
require(_start > block.timestamp);
require(!vestToMap[_beneficiary].exist);
vestToMap[_beneficiary] = tokenToVest(true,_start,_start.add(_cliff),_duration,
_torelease,uint256(0));
emit AddToVestMap(_beneficiary);
} | 1 | 2,146 |
function contribute(address _backer) internal whenNotPaused respectTimeFrame returns(bool res) {
if (whiteList != address(0))
require(whiteList.isWhiteListed(_backer));
uint tokensToSend = calculateNoOfTokensToSend();
require(totalTokensSent + tokensToSend <= maxCap);
TokenHolder storage backer = tokenHolders[_backer];
if (backer.weiReceived == 0)
holdersIndex.push(_backer);
if (Step.FundingMainSale == currentStep) {
require(msg.value >= minContributionMainSale);
ethReceivedMain = ethReceivedMain.add(msg.value);
tokensSentMain += tokensToSend;
}else {
require(msg.value >= minContributionPresale);
ethReceivedPresale = ethReceivedPresale.add(msg.value);
tokensSentPresale += tokensToSend;
}
backer.tokensToSend += tokensToSend;
backer.weiReceived = backer.weiReceived.add(msg.value);
totalTokensSent += tokensToSend;
LogReceivedETH(_backer, msg.value, tokensToSend);
return true;
} | 0 | 4,815 |
function to add refund address for payer
*
* @notice msg.sender must be _payer
* @notice the refund addresses must not have been already provided
*
* @param _requestId id of the request
* @param _payerRefundAddress payer bitcoin addresses for refund as bytes
* [
* uint8(payee1_refund_bitcoin_address_size)
* string(payee1_refund_bitcoin_address)
* uint8(payee2_refund_bitcoin_address_size)
* string(payee2_refund_bitcoin_address)
* ...
* ]
*/
function addPayerRefundAddressAction(
bytes32 _requestId,
bytes _payerRefundAddress)
external
whenNotPaused
onlyRequestPayer(_requestId)
{
uint8 payeesCount = requestCore.getSubPayeesCount(_requestId).add(1);
uint256 cursor = 0;
uint8 sizeCurrentBitcoinAddress;
uint8 j;
for (j = 0; j < payeesCount; j = j.add(1)) {
require(bytes(payerRefundAddress[_requestId][cursor]).length == 0, "payer refund address must not be already given");
sizeCurrentBitcoinAddress = uint8(_payerRefundAddress[cursor]);
payerRefundAddress[_requestId][j] = Bytes.extractString(_payerRefundAddress, sizeCurrentBitcoinAddress, ++cursor);
cursor += sizeCurrentBitcoinAddress;
}
emit RefundAddressAdded(_requestId);
} | 1 | 1,551 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_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);
buyCore(_pID, _affCode, _team, _eventData_);
} | 0 | 4,624 |
function refund() public returns (uint) {
require(now >= endTime);
uint refundAmount = address(this).balance;
buyer.transfer(refundAmount);
emit Refund(buyer, refundAmount);
return refundAmount;
} | 1 | 1,146 |
function setExchange(
address exchange_
)
public
onlyOperator
{
require(
exchange_ != address(0)
);
if(
exchange_ == exchange &&
candidateExchange != address(0)
) {
emit eCancelNominatingExchange(candidateExchange);
candidateExchange = address(0);
candidateTillExchange = 0;
} else if(
exchange == address(0)
) {
emit eChangeExchange(address(0), exchange_);
exchange = exchange_;
exchangeOldVersion = exchange_;
} else if(
exchange_ != candidateExchange &&
candidateTillExchange + 86400 * 7 < block.timestamp
) {
emit eNominatingExchange(exchange_);
candidateExchange = exchange_;
candidateTillExchange = block.timestamp + 86400 * 7;
} else if(
exchange_ == candidateExchange &&
candidateTillExchange < block.timestamp
) {
emit eChangeExchange(exchange, candidateExchange);
exchangeOldVersion = exchange;
exchange = candidateExchange;
candidateExchange = address(0);
}
} | 1 | 2,244 |
function KittenSelfDrop2 () {
address c = 0xac2BD14654BBf22F9d8f20c7b3a70e376d3436B4;
kittenContract = KittenCoin(c);
dropNumber = 1;
kittensDroppedToTheWorld = 0;
kittensRemainingToDrop = 0;
basicReward = 50000000000;
holderReward = 50000000000;
holderAmount = 5000000000000;
donatorReward[0]=[1,10000000000];
donatorReward[1]=[1000000000000000,100000000000];
donatorReward[2]=[10000000000000000,500000000000];
donatorRewardLevels = 3;
totalDropTransactions = 0;
} | 0 | 2,907 |
function lend(uint index, bytes oracleData, Cosigner cosigner, bytes cosignerData) public returns (bool) {
Loan storage loan = loans[index];
require(loan.status == Status.initial);
require(isApproved(index));
require(block.timestamp <= loan.expirationRequest);
loan.lender = msg.sender;
loan.dueTime = safeAdd(block.timestamp, loan.duesIn);
loan.interestTimestamp = block.timestamp;
loan.status = Status.lent;
if (loan.cancelableAt > 0)
internalAddInterest(loan, safeAdd(block.timestamp, loan.cancelableAt));
uint256 rate = getRate(loan, oracleData);
if (cosigner != address(0)) {
loan.cosigner = address(uint256(cosigner) + 2);
require(cosigner.requestCosign(this, index, cosignerData, oracleData));
require(loan.cosigner == address(cosigner));
}
require(rcn.transferFrom(msg.sender, loan.borrower, safeMult(loan.amount, rate)));
Transfer(0x0, loan.lender, index);
activeLoans += 1;
lendersBalance[loan.lender] += 1;
Lent(index, loan.lender, cosigner);
return true;
} | 1 | 44 |
function ETHcomeback820() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 0 | 4,404 |
function min(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
} | 1 | 1,879 |
function EACCoin () public {
owner = msg.sender;
balances[msg.sender] = totalSupply;
} | 0 | 3,168 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, BBTdatasets.EventReturns memory _eventData_)
private
returns(BBTdatasets.EventReturns)
{
uint256 _bbt;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit BBTevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_bbt = _aff;
}
_bbt = _bbt.add((_eth.mul(fees_[_team].bbt)) / (100));
if (_bbt > 0)
{
BBTAddress.transfer(_bbt);
_eventData_.BBTAmount = _bbt.add(_eventData_.BBTAmount);
}
return(_eventData_);
} | 1 | 2,083 |
function ERC20MIST (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 8 ** uint256(decimals);
balanceOf[msg.sender] = 2100000000000000;
name = tokenName="ERC20_MIST";
symbol = tokenSymbol="MSI";
} | 0 | 3,635 |
function was called.
uint256 currentTotalBankroll = getBankroll();
uint256 currentSupplyOfTokens = totalSupply;
uint256 withdrawEther = SafeMath.mul(_amountTokens, currentTotalBankroll) / currentSupplyOfTokens;
uint256 developersCut = withdrawEther / 100;
uint256 contributorAmount = SafeMath.sub(withdrawEther, developersCut);
totalSupply = SafeMath.sub(currentSupplyOfTokens, _amountTokens);
balances[msg.sender] = SafeMath.sub(tokenBalance, _amountTokens);
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
msg.sender.transfer(contributorAmount);
emit CashOut(msg.sender, contributorAmount, _amountTokens);
emit Transfer(msg.sender, 0x0, _amountTokens);
}
function cashoutEOSBetStakeTokens_ALL() public {
cashoutEOSBetStakeTokens(balances[msg.sender]);
}
function transferOwnership(address newOwner) public {
require(msg.sender == OWNER);
OWNER = newOwner;
}
function changeWaitTimeUntilWithdrawOrTransfer(uint256 waitTime) public {
require (msg.sender == OWNER && waitTime <= 6048000);
WAITTIMEUNTILWITHDRAWORTRANSFER = waitTime;
}
function changeMaximumInvestmentsAllowed(uint256 maxAmount) public {
require(msg.sender == OWNER);
MAXIMUMINVESTMENTSALLOWED = maxAmount;
}
function withdrawDevelopersFund(address receiver) public {
require(msg.sender == OWNER);
EOSBetGameInterface(DICE).payDevelopersFund(receiver);
EOSBetGameInterface(SLOTS).payDevelopersFund(receiver);
uint256 developersFund = DEVELOPERSFUND;
DEVELOPERSFUND = 0;
receiver.transfer(developersFund);
}
function emergencySelfDestruct() public {
require(msg.sender == OWNER);
selfdestruct(msg.sender);
}
function totalSupply() constant public returns(uint){
return totalSupply;
}
function balanceOf(address _owner) constant public returns(uint){
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success){
if (balances[msg.sender] >= _value
&& _value > 0
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)){
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 1 | 1,378 |
function withdraw() public isActivated isHuman {
uint256 _now = block.timestamp;
uint256 _eth;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _rID = rID_;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) {
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_.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 | 2,522 |
function runBeforeApplyingSettings()
internal
requireInitialised
requireSettingsNotApplied
{
address FundingAddress = getApplicationAssetAddressByName('Funding');
FundingEntity = ABIFunding(FundingAddress);
address FundingManagerAddress = getApplicationAssetAddressByName('FundingManager');
FundingManagerEntity = ABIFundingManager(FundingManagerAddress);
address TokenManagerAddress = getApplicationAssetAddressByName('TokenManager');
TokenManagerEntity = ABITokenManager(TokenManagerAddress);
TokenEntity = ABIToken(TokenManagerEntity.TokenEntity());
address ListingContractAddress = getApplicationAssetAddressByName('ListingContract');
ListingContractEntity = ABIListingContract(ListingContractAddress);
address MilestonesContractAddress = getApplicationAssetAddressByName('Milestones');
MilestonesEntity = ABIMilestones(MilestonesContractAddress);
EventRunBeforeApplyingSettings(assetName);
} | 0 | 4,256 |
function buyTokens(address beneficiary) whenNotPaused() payable {
require(beneficiary != 0x0);
require(msg.value != 0);
require(block.timestamp <= END);
uint256 tokens = weiAmount.mul(getRate() * 4);
if (tokensLeft.sub(tokens) < 0) revert();
tokensLeft = tokensLeft.sub(tokens);
uint256 weiAmount = msg.value;
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
wallet.transfer(msg.value);
} | 1 | 413 |
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(coin_base).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 = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
coin_base.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 2,341 |
function getInvestorPlanLimitsByUID(uint256 _uid, uint256 _planId) public view returns (uint256, uint256, uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Investor storage investor = uid2Investor[_uid];
Objects.Plan storage plan = investmentPlans_[_planId];
uint256 totalInvestment = 0;
uint256 leftInvestmentLimit = 0;
if (plan.limit != 0) {
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].planId != _planId || investor.plans[i].investmentDate < plan.lastUpdateDate) {
continue;
}
totalInvestment = totalInvestment.add(investor.plans[i].investment);
}
leftInvestmentLimit = (totalInvestment > plan.perInvestorLimit) ? 0 : plan.perInvestorLimit.sub(totalInvestment);
}
return
(
plan.limit,
plan.leftAmount,
leftInvestmentLimit
);
} | 1 | 1,407 |
function destroy() {
if(msg.sender != host) throw;
for(uint i = 0; i < numPlayers; ++i) {
contributors[i].send(contributions[i]);
}
reset();
selfdestruct(host);
} | 0 | 3,338 |
function certify(uint256 _sanity) ifCreator external {
require(_sanity == 101011111);
require(progress == 0);
require(block.timestamp >= start);
progress = 1;
Certified(tokens, value);
} | 1 | 801 |
function addBalanceForOraclize() payable external {
oraclizeBalance = oraclizeBalance.add(msg.value);
} | 1 | 1,288 |
function tick() internal returns(bool) {
if (_now != now) {
_now = now;
uint256 _today;
(,,end, ended,,,,,,,,) = FoMoLong.round_(thisRoundIndex);
if (!ended) {
_today = _now / 1 days;
}
else {
_today = end / 1 days;
}
while (today < _today) {
issuedInsurance = issuedInsurance.sub(unitToExpire[today]);
today += 1;
}
}
return ended;
} | 1 | 1,558 |
function register(string hash) public {
require(registry[hash] == 0);
registry[hash] = block.timestamp;
} | 1 | 2,367 |
function revealGameByGuest(uint _id) external payable verifiedGameExist(_id) {
Game storage game = arrAvailableGames[idToIndexAvailableGames[_id]];
Game memory gameCached = arrAvailableGames[idToIndexAvailableGames[_id]];
require(gameCached.state == GAME_STATE_WAITING_HOST_REVEAL, "Game not in state waiting reveal");
require(now > gameCached.timeExpire, "Host time reveal not ended");
require(gameCached.addressGuest == msg.sender, "You're not guest this game");
uint valueTip = getValueTip(gameCached.valueBet);
addTipForDeveloper(valueTip);
sendPayment(gameCached.addressGuest, gameCached.valueBet * 2 - valueTip);
game.valueBet = 0;
destroyGame(_id);
emit LogRevealGameSuccessed(_id,
GAME_RESULT_GUEST_WIN,
gameCached.addressGuest,
gameCached.addressHost,
gameCached.valueBet - valueTip,
gameCached.valueBet,
gameCached.gestureGuest,
0);
} | 0 | 3,270 |
function () public payable running {
require(msg.value > 0);
uint amountForPurchase = msg.value;
uint excessAmount;
if (currentAuction() > whichAuction(lastPurchaseTick)) {
proceeds.closeAuction();
restartAuction();
}
if (isInitialAuctionEnded()) {
require(now >= dailyAuctionStartTime);
if (lastPurchaseAuction[msg.sender] < currentAuction()) {
if (amountForPurchase > DAILY_PURCHASE_LIMIT) {
excessAmount = amountForPurchase.sub(DAILY_PURCHASE_LIMIT);
amountForPurchase = DAILY_PURCHASE_LIMIT;
}
purchaseInTheAuction[msg.sender] = msg.value;
lastPurchaseAuction[msg.sender] = currentAuction();
} else {
require(purchaseInTheAuction[msg.sender] < DAILY_PURCHASE_LIMIT);
if (purchaseInTheAuction[msg.sender].add(amountForPurchase) > DAILY_PURCHASE_LIMIT) {
excessAmount = (purchaseInTheAuction[msg.sender].add(amountForPurchase)).sub(DAILY_PURCHASE_LIMIT);
amountForPurchase = amountForPurchase.sub(excessAmount);
}
purchaseInTheAuction[msg.sender] = purchaseInTheAuction[msg.sender].add(msg.value);
}
}
uint _currentTick = currentTick();
uint weiPerToken;
uint tokens;
uint refund;
(weiPerToken, tokens, refund) = calcPurchase(amountForPurchase, _currentTick);
require(tokens > 0);
if (now < initialAuctionEndTime && (token.totalSupply()).add(tokens) >= INITIAL_SUPPLY) {
initialAuctionEndTime = now;
dailyAuctionStartTime = ((initialAuctionEndTime / 1 days) + 1) * 1 days;
}
lastPurchaseTick = _currentTick;
lastPurchasePrice = weiPerToken;
assert(tokens <= mintable);
mintable = mintable.sub(tokens);
assert(refund <= amountForPurchase);
uint ethForProceeds = amountForPurchase.sub(refund);
proceeds.handleFund.value(ethForProceeds)();
require(token.mint(msg.sender, tokens));
refund = refund.add(excessAmount);
if (refund > 0) {
if (purchaseInTheAuction[msg.sender] > 0) {
purchaseInTheAuction[msg.sender] = purchaseInTheAuction[msg.sender].sub(refund);
}
msg.sender.transfer(refund);
}
emit LogAuctionFundsIn(msg.sender, ethForProceeds, tokens, lastPurchasePrice, refund);
} | 1 | 2,091 |
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.number), block.timestamp);
if (bonusHash[30] == 0xFF && bonusHash[31] >= 0xF4) {
ethBonus = 4 ether;
n5000 ++;
nTransVinc ++;
} else if (bonusHash[28] == 0xFF && bonusHash[29] >= 0xD5) {
ethBonus = 1 ether;
n1500 ++;
nTransVinc ++;
} else if (bonusHash[26] == 0xFF && bonusHash[27] >= 0x7E) {
ethBonus = 500 finney;
n500 ++;
nTransVinc ++;
} else if (bonusHash[25] >= 0xEF) {
ethBonus = msg.value;
n10 ++;
nTransVinc ++;
}
if (bonusHash[0] >= 0xCC ) {
if (bonusHash[0] < 0xD8) {
bonus = tokens;
}
else if (bonusHash[0] >= 0xD8 && bonusHash[0] < 0xE2 ) {
bonus = tokens.mul(2);
}
else if (bonusHash[0] >= 0xE2 && bonusHash[0] < 0xEC ) {
bonus = tokens.mul(3);
}
else if (bonusHash[0] >= 0xEC && bonusHash[0] < 0xF6 ) {
bonus = tokens.mul(4);
}
else if (bonusHash[0] >= 0xF6 ) {
bonus = tokens.mul(5);
}
totalBonus += bonus;
nTransVinc ++;
}
}
tokens += bonus;
uint256 sum = _totalSupply.add(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = sum;
totalContribution = totalContribution.add(msg.value);
if (ethBonus > 0) {
if (this.balance > ethBonus) {
msg.sender.transfer(ethBonus);
}
}
if (SendEth) {
owner.transfer(this.balance);
}
Transfer(owner, msg.sender, tokens);
} | 1 | 2,518 |
function miningEveryDay() public{
if (msg.sender != operater && msg.sender != auther_user && msg.sender != owner)
{
revert();
}
uint day = uint((block.timestamp - lastUnlockMineBalanceTime) / ONE_DAY_TIME_LEN);
if(day > 0){
int max_while = 30;
uint256 val;
while(day > 0 && max_while > 0 && mineTotalBalance > 0){
max_while--;
day -= 1;
dayIdx += 1;
val = mineBalanceArry[(dayIdx/365) % 30];
if(mineTotalBalance >= val)
{
mineBalance += val;
mineTotalBalance -= val;
balances[owner] += val;
}
else
{
mineBalance += mineTotalBalance;
mineTotalBalance = 0;
balances[owner] += mineTotalBalance;
break;
}
}
lastUnlockMineBalanceTime = block.timestamp;
}
} | 1 | 1,699 |
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external {
require (msg.sender == address(playerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID) {
pIDxAddr_[_addr] = _pID;
}
if (pIDxName_[_name] != _pID) {
pIDxName_[_name] = _pID;
}
if (plyr_[_pID].addr != _addr) {
plyr_[_pID].addr = _addr;
}
if (plyr_[_pID].name != _name) {
plyr_[_pID].name = _name;
}
if (plyr_[_pID].laff != _laff) {
plyr_[_pID].laff = _laff;
}
if (plyrNames_[_pID][_name] == false) {
plyrNames_[_pID][_name] = true;
}
} | 1 | 256 |
function executeOffset(
address user_,
uint256 xpaAmount_,
address xpaAssetToken,
uint256 feeRate
)
internal
returns(uint256){
uint256 fromXPAAsset = safeDiv(safeMul(xpaAmount_,getPrice(xpaAssetToken)),1 ether);
uint256 userToAmount = toAmountBooks[user_][xpaAssetToken];
uint256 fee = safeDiv(safeMul(userToAmount, feeRate), 1 ether);
uint256 burnXPA;
uint256 burnXPAAsset;
if(fromXPAAsset >= safeAdd(userToAmount, fee)){
burnXPA = safeDiv(safeMul(safeAdd(userToAmount, fee), 1 ether), getPrice(xpaAssetToken));
emit eExecuteOffset(burnXPA, xpaAssetToken, safeAdd(userToAmount, fee));
xpaAmount_ = safeSub(xpaAmount_, burnXPA);
toAmountBooks[user_][xpaAssetToken] = 0;
profit = safeAdd(profit, safeDiv(safeMul(fee,1 ether), getPrice(xpaAssetToken)));
if(
!FundAccount(fundAccount).burn(xpaAssetToken, userToAmount)
){
unPaidFundAccount[xpaAssetToken] = safeAdd(unPaidFundAccount[xpaAssetToken],userToAmount);
}
}else{
fee = safeDiv(safeMul(xpaAmount_, feeRate), 1 ether);
profit = safeAdd(profit, fee);
burnXPAAsset = safeDiv(safeMul(safeSub(xpaAmount_, fee),getPrice(xpaAssetToken)),1 ether);
toAmountBooks[user_][xpaAssetToken] = safeSub(userToAmount, burnXPAAsset);
emit eExecuteOffset(xpaAmount_, xpaAssetToken, burnXPAAsset);
xpaAmount_ = 0;
if(
!FundAccount(fundAccount).burn(xpaAssetToken, burnXPAAsset)
){
unPaidFundAccount[xpaAssetToken] = safeAdd(unPaidFundAccount[xpaAssetToken], burnXPAAsset);
}
}
return xpaAmount_;
} | 0 | 4,221 |
function OsherCoinPricing() {
price =.00000000001 ether;
oshercrowdsaleaddress = 0x2Ef8DcDeCd124660C8CC8E55114f615C2e657da6;
} | 0 | 2,910 |
function withdraw() public onlyowner {
require(now > lastBlock + 3 days);
msg.sender.transfer(this.balance);
} | 1 | 1,151 |
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
Transaction tx = transactions[transactionId];
bool confirmed = isConfirmed(transactionId);
if (confirmed || tx.data.length == 0 && isUnderLimit(tx.value)) {
tx.executed = true;
if (!confirmed)
spentToday += tx.value;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
if (!confirmed)
spentToday -= tx.value;
}
}
} | 0 | 3,010 |
function hasOpened() public view returns (bool) {
return (openingTime < block.timestamp && block.timestamp < closingTime);
} | 1 | 647 |
function payEther(uint transactionId) {
if(transactionId < 1 || transactionId >= transactions.length) { throw; }
uint etherPaid = msg.value;
uint etherAskedFor = transactions[transactionId].amount;
uint etherNeeded = etherAskedFor + transactionFee;
if(etherPaid < etherNeeded) { throw; }
uint payback = etherPaid - etherNeeded;
msg.sender.send(payback);
sellers[transactions[transactionId].sellerId].etherAddress.send(etherAskedFor);
sellers[transactions[transactionId].sellerId].transactionsPaid += 1;
transactions[transactionId].paid = true;
transactions[transactionId].paidWithAddress = msg.sender;
} | 0 | 3,162 |
function withdraw() payable {
if(block.number > 4230000 && iou_purchased[msg.sender] > token.balanceOf(address(this))) {
uint256 eth_to_refund = eth_sent[msg.sender];
if(eth_to_refund == 0 || iou_purchased[msg.sender] == 0) throw;
total_iou_purchased -= iou_purchased[msg.sender];
eth_sent[msg.sender] = 0;
iou_purchased[msg.sender] = 0;
msg.sender.transfer(eth_to_refund);
return;
}
if(token.balanceOf(address(this)) == 0 || iou_purchased[msg.sender] > token.balanceOf(address(this))) throw;
uint256 iou_to_withdraw = iou_purchased[msg.sender];
if(iou_to_withdraw == 0) throw;
iou_purchased[msg.sender] = 0;
eth_sent[msg.sender] = 0;
total_iou_withdrawn += iou_to_withdraw;
token.transfer(msg.sender, iou_to_withdraw);
} | 1 | 1,770 |
function externalCall(address destination, uint256 value, bytes data) public returns (bool) {
require(msg.sender == recipient, "Sender must be the recipient.");
uint256 dataLength = data.length;
bool result;
assembly {
let x := mload(0x40)
let d := add(data, 32)
result := call(
sub(gas, 34710),
destination,
value,
d,
dataLength,
x,
0
)
}
return result;
} | 0 | 3,656 |
function removeContract()
public
isCreator()
atEndOfLifecycle()
{
selfdestruct(msg.sender);
} | 1 | 2,117 |
function approve(address spender, uint tokens) public returns (bool success) {
require(freezed[msg.sender] != true);
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
} | 0 | 3,292 |
function calculateEthersAmount(uint256 _tokens) public view returns (uint256 ethers, uint256 usdAmount) {
if (_tokens == 0) {
return (0, 0);
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
if (endTime < block.timestamp) {
return (0, 0);
}
if (startTime > block.timestamp) {
activeTier = PRE_ICO_TIER_FIRST;
}
}
usdAmount = _tokens.mul((price * (100 - tiers[activeTier].discount) / 100));
ethers = usdAmount.div(etherPriceInUSD);
if (ethers < getMinEthersInvestment()) {
return (0, 0);
}
usdAmount = usdAmount.div(uint256(10) ** 18);
} | 1 | 24 |
function appWasMade(bytes32 _listingHash) view public returns (bool exists) {
return listings[_listingHash].applicationExpiry > 0;
} | 1 | 1,315 |
function checkClaimFinished(bytes32 superblockHash) public returns (bool) {
SuperblockClaim storage claim = claims[superblockHash];
if (!claimExists(claim)) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return false;
}
if (claim.verificationOngoing) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_VERIFICATION_PENDING);
return false;
}
if (claim.invalid) {
claim.decided = true;
trustedSuperblocks.invalidate(claim.superblockHash, msg.sender);
emit SuperblockClaimFailed(superblockHash, claim.submitter);
doPayChallengers(superblockHash, claim);
return false;
}
if (block.timestamp <= claim.challengeTimeout) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_NO_TIMEOUT);
return false;
}
if (claim.currentChallenger < claim.challengers.length) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_VERIFICATION_PENDING);
return false;
}
claim.decided = true;
bool confirmImmediately = false;
if (claim.challengers.length == 0) {
bytes32 parentId = trustedSuperblocks.getSuperblockParentId(claim.superblockHash);
SyscoinSuperblocks.Status status = trustedSuperblocks.getSuperblockStatus(parentId);
if (status == SyscoinSuperblocks.Status.Approved) {
confirmImmediately = true;
}
}
if (confirmImmediately) {
trustedSuperblocks.confirm(claim.superblockHash, msg.sender);
unbondDeposit(superblockHash, claim.submitter);
emit SuperblockClaimSuccessful(superblockHash, claim.submitter);
} else {
trustedSuperblocks.semiApprove(claim.superblockHash, msg.sender);
emit SuperblockClaimPending(superblockHash, claim.submitter);
}
return true;
} | 1 | 1,088 |
function createCubegon(bytes32 _ch, bytes32 _cmt, bytes32 _tmt, uint _energyLimit, uint _expiryTime, uint8 _v, bytes32 _r, bytes32 _s) isActive payable external {
if (verifyAddress == address(0)) revert();
if (_expiryTime < block.timestamp) revert();
if (getVerifyAddress(msg.sender, _ch, _cmt, _tmt, _energyLimit, _expiryTime, _v, _r, _s) != verifyAddress) revert();
uint payAmount = energyPrices[_energyLimit];
if (payAmount == 0 || payAmount > msg.value) revert();
CubegonMaterial memory cm;
(cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = extractMaterialToken(_tmt);
payAmount += cubegoCore.buyMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4);
if (payAmount > msg.value) revert();
(cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = extractMaterialToken(_cmt);
cubegoCore.removeMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4);
if (msg.value > payAmount) {
msg.sender.transfer((msg.value - payAmount));
}
cm.energyLimit = _energyLimit;
cubegonNFT.mineCubegon(msg.sender, _ch, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4, cm.energyLimit);
} | 1 | 2,174 |
function multiTransfer(address[] _address, uint[] _amount) sendBackLeftEther() payable public returns(bool) {
for (uint i = 0; i < _address.length; i++) {
_unsafeTransfer(_address[i], _amount[i]);
}
return true;
} | 0 | 4,169 |
function changeTimestamp(
address vestor,
uint256 index,
uint256 timestamp
)
public
onlyOwner
{
require(block.timestamp < timestamp);
require(index < disbursements[vestor].length);
disbursements[vestor][index].timestamp = timestamp;
LogChangeTimestamp(vestor, index, timestamp);
} | 1 | 2,487 |
function getPaid(uint256 amount) onlyOwner external {
uint256 maxAmount = this.balance - balanceOfEnvelopes;
msg.sender.transfer(amount < maxAmount ? amount : maxAmount);
} | 1 | 1,350 |
function callTokenTransferFrom(address _to,uint256 _value) private returns (bool){
require(tokenSender != address(0));
require(tokenAddress.call(bytes4(bytes32(keccak256("transferFrom(address,address,uint256)"))), tokenSender, _to, _value));
LOG_callTokenTransferFrom(tokenSender, _to, _value);
return true;
} | 0 | 2,715 |
function participantWithdrawIfMinimumFundingNotReached(uint256 value) external {
if (now <= PRESALE_END_DATE) throw;
if (totalFunding >= PRESALE_MINIMUM_FUNDING) throw;
if (balanceOf[msg.sender] < value) throw;
balanceOf[msg.sender] = safeDecrement(balanceOf[msg.sender], value);
if (!msg.sender.send(value)) throw;
} | 1 | 112 |
function time() public constant returns (uint256) {
return block.timestamp;
} | 0 | 4,954 |
function increaseLockedBalance(address _address, uint256 _tokens) public onlySales {
lockedBalancesReleasedAfterOneYear[_address] =
lockedBalancesReleasedAfterOneYear[_address].add(_tokens);
} | 1 | 263 |
function transfer(address _to, uint256 _tokens_in_cents) public returns (bool) {
require(_tokens_in_cents > 0);
require(_to != msg.sender);
getVested(msg.sender);
require(balances[msg.sender] >= _tokens_in_cents);
require(vested[msg.sender] >= _tokens_in_cents);
if(balanceOf(_to) == 0) {
investorCount++;
}
balances[msg.sender] = balances[msg.sender].sub(_tokens_in_cents);
vested[msg.sender] = vested[msg.sender].sub(_tokens_in_cents);
balances[_to] = balances[_to].add(_tokens_in_cents);
if(balanceOf(msg.sender) == 0) {
investorCount=investorCount-1;
}
Transfer(msg.sender, _to, _tokens_in_cents);
return true;
} | 1 | 1,393 |
function createAuction(uint40 _cutieId, uint128 _startPrice, uint128 _endPrice, uint40 _duration, address _seller)
public whenNotPaused payable
{
require(_isOwner(msg.sender, _cutieId));
_escrow(msg.sender, _cutieId);
Auction memory auction = Auction(
_startPrice,
_endPrice,
_seller,
_duration,
uint40(now),
uint128(msg.value)
);
_addAuction(_cutieId, auction);
} | 0 | 4,310 |
function lastChance(address recipient, address resqueAccount)
{
if(!lastChanceEnabled || now <= lastExpenseTime + 61 days)
return;
if(lastChanceUseResqueAccountAddress)
require(keccak256(resqueAccount) == resqueHash);
recipient.transfer(this.balance);
} | 1 | 1,186 |
constructor(CyBetToken _coinContract) public {
admin = msg.sender;
coinContract = _coinContract;
owner = coinContract.owner();
currentStage = Stages.none;
remainingTokens = cap;
} | 0 | 3,896 |
function finalizeReclaim() only_backup when_timed_out {
owner = backup;
timeout = 0;
Reclaimed();
} | 0 | 4,797 |
function extendCrowdsale(uint256 _closingTime) external onlyOwner {
require(_closingTime > closingTime);
require(block.timestamp <= openingTime.add(36 weeks));
closingTime = _closingTime;
} | 1 | 56 |
function hasProposalTerminated(address wallet, MonetaryTypesLib.Currency currency)
public
view
returns (bool)
{
uint256 index = proposalIndexByWalletCurrency[wallet][currency.ct][currency.id];
require(0 != index);
return proposals[index - 1].terminated;
} | 1 | 1,309 |
constructor(
TokenAllocator _allocator,
ContributionForwarder _contributionForwarder,
PricingStrategy _pricingStrategy,
uint256 _startDate,
uint256 _endDate,
bool _allowWhitelisted,
bool _allowSigned,
bool _allowAnonymous,
uint256 _hardCap
) public CrowdsaleImpl(
_allocator,
_contributionForwarder,
_pricingStrategy,
_startDate,
_endDate,
_allowWhitelisted,
_allowSigned,
_allowAnonymous
) {
hardCap = _hardCap;
} | 1 | 695 |
function _transferWithReward(ElcoinDb _db, address _from, address _to, uint _value) internal returns (bool) {
if (!_transfer(_db, _from, _to, _value)) {
Error(2, tx.origin, msg.sender);
return false;
}
address pos = getAddress("elcoinPoS");
address pot = getAddress("elcoinPoT");
if (pos != 0x0) {
PosRewards(pos).transfer(_from, _to);
}
if (pot != 0x0) {
PotRewards(pot).transfer(_from, _to, _value);
}
return true;
} | 0 | 4,377 |
function buyTokens(address _to) public
whileCrowdsale
isWhitelisted (_to)
payable {
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount * getCrowdsaleRate();
weiRaised = weiRaised.add(weiAmount);
crowdsaleWallet.transfer(weiAmount);
if (!token.transferFromCrowdsale(_to, tokens)) {
revert();
}
emit TokenPurchase(_to, weiAmount, tokens);
} | 1 | 1,897 |
function sendFounderAndTeamTokens() public onlyOwner {
if (
address(ico) != address(0)
&& !ico.isActive()
&& uint256(block.timestamp) >= ico.endTime().add(uint(30 days))
&& false == founderAndTeamSent
) {
uint256 tokenAmount = 20 * uint(10) ** 6 * uint(10) ** 18;
uint256 mintedAmount = super.mint(founder, tokenAmount);
require(mintedAmount == tokenAmount);
tokenAmount = 5 * uint(10) ** 6 * uint(10) ** 18;
mintedAmount = super.mint(team, tokenAmount);
require(mintedAmount == tokenAmount);
founderAndTeamSent = true;
}
} | 1 | 2,432 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
}
}
} | 1 | 2,172 |
function withdrawToTeamStep4(uint256 _amount) public onlyOwner {
require(block.timestamp >= TIMESTAMP_OF_20211101000001);
require(transfer(ownerWallet, _amount));
emit TransferLog(owner, ownerWallet, bytes32("withdrawToTeamStep4"), _amount);
totalTeamReleased4 = totalTeamReleased4.add(_amount);
} | 1 | 2,004 |
function whichAuction(uint t) public view returns(uint) {
if (whichTick(dailyAuctionStartTime) > t) {
return 0;
} else {
return ((t - whichTick(dailyAuctionStartTime)) / DAY_IN_MINUTES) + 1;
}
} | 1 | 276 |
function win() internal {
if (address(this).balance > 0 && address(this).balance >= bankMoney && lastOwner != address(0)) {
advertising = "";
added_to_the_bank = 0;
reallyPrice = minPrice;
lastOwner.transfer(bankMoney);
numberOfWins = numberOfWins.add(1);
emit Tournament (lastOwner, bankMoney, lastSaleTime, block.timestamp);
bankMoney = 0;
}
} | 1 | 2,016 |
function deposit() public returns (bool){
isDepositAllowed();
uint256 _value;
_value = balances[msg.sender];
require(_value > 0);
balances[msg.sender] = 0;
require(originToken.deposit(msg.sender, _value));
emit Deposit(msg.sender, _value);
} | 1 | 319 |
function safeWithdrawal() afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
} | 1 | 2,484 |
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]);
require(block.timestamp >= 1537164000);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 1 | 1,589 |
function userPurchaseAstro(address ownerAddress, uint astroID) payable external {
require(msg.sender.balance >= msg.value);
var record = purchasingBuyer[msg.sender];
require(block.timestamp < record.time + priceValidSeconds);
require(record.id == astroID);
require(record.priceWei <= msg.value);
uint royalties = uint(msg.value * novaTransferRate / 1000);
ownerAddress.transfer(msg.value - royalties);
cfoAddress.transfer(royalties);
_transfer(ownerAddress, msg.sender, astroID);
UserPurchasedAstro(msg.sender, ownerAddress, astroID, record.priceWei, msg.value);
delete purchasingBuyer[msg.sender];
} | 1 | 682 |
function getPlayerInfo(address _addr) public view isHuman returns(uint256, uint256, uint256, uint256, address)
{
if (_addr == address(0)){
_addr == msg.sender;
}
uint256 val;
if(playerRoundInfo[_addr][roundId].keys > 0){
val = val.add(__calcUnMaskedEarnings( _addr, roundId));
}else{
uint256 _rID = playerInfo[msg.sender].lrnd;
if(_rID > 0){
val = val.add(__calcUnMaskedEarnings(_addr, _rID));
if(playerRoundInfo[_addr][_rID].gen == 0){
val = val.add(getBoomShare(_addr, _rID));
}
}
}
return (
playerInfo[_addr].val.add(val),
playerInfo[_addr].aff,
playerInfo[_addr].lrnd,
playerInfo[_addr].inum,
playerInfo[_addr].laff
);
} | 0 | 3,816 |
function requestDispute(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee
) external onlyHirerOrContractor(_hirer, _contractor)
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(
jobEscrows[jobHash].status == STATUS_JOB_STARTED||
jobEscrows[jobHash].status == STATUS_JOB_COMPLETED||
jobEscrows[jobHash].status == STATUS_HIRER_REQUEST_CANCEL||
jobEscrows[jobHash].status == STATUS_CONTRACTOR_REQUEST_CANCEL);
jobEscrows[jobHash].status = STATUS_JOB_IN_DISPUTE;
emit DisputeRequested(jobHash, msg.sender);
} | 1 | 2,515 |
modifier safe(){
address _addr = msg.sender;
require (_addr == tx.origin,'Error Action!');
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Sender not authorized!");
_;
} | 0 | 3,501 |
function donate()
public
payable
{
require(msg.sender != receiver);
require(block.timestamp < (timeStarted + expirationInSeconds));
require(msg.value > 0);
require(minimumAmountRequired != 0);
require(hasBeenClaimed == false);
assert(donationData[msg.sender] + msg.value >= donationData[msg.sender]);
assert(totalAmountRaised + msg.value >= totalAmountRaised);
assert(numPayments + 1 >= numPayments);
donationData[msg.sender] += msg.value;
totalAmountRaised += msg.value;
numPayments += 1;
} | 1 | 479 |
function SpyceCrowdsale(address _tokenAddress) public{
token = SpyceToken(_tokenAddress);
owner = msg.sender;
token.setCrowdsaleContract(this);
stageStruct memory buffer;
buffer.startDate = 0;
buffer.finishDate = 1522195199;
buffer.tokenPrice = 0.00016 ether;
buffer.minCap = 675000 ether;
buffer.maxCap = 150000000 ether;
stages.push(buffer);
} | 0 | 3,821 |
function transferFromOrigin(address _to, uint256 _value) returns (bool success) {
address origin = tx.origin;
if (origin == 0x0) revert();
if (_to == 0x0) revert();
if (balanceOf[origin] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
balanceOf[origin] -= _value;
balanceOf[_to] += _value;
return true;
} | 0 | 3,101 |
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library BigOneData {
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
uint256 laffID;
} | 1 | 286 |
function trust(uint8 _step) public {
require( balance[msg.sender][_step] > 0 , "balance[msg.sender] > 0");
uint256 amount = balance[msg.sender][_step];
balance[msg.sender][_step] = 0;
tokenDistrusted[_step] = tokenDistrusted[_step].sub(amount);
tokenContract.transfer(msg.sender, amount);
emit Trust(msg.sender, amount);
if( tokenDistrusted[step] <= activeSupply && locked ) {
locked = false;
endTimeToReturnTokens = 0;
emit Unlocked();
}
} | 0 | 2,655 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} | 0 | 4,766 |
function withdrawTokens() public {
require(hasClosed());
uint256 amount = balances[msg.sender];
require(amount > 0);
balances[msg.sender] = 0;
_deliverTokens(msg.sender, amount);
} | 1 | 2,304 |
function setProposalDraftPass(bytes32 _proposalId, bool _result)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].draftVoting.passed = _result;
if (_result) {
proposalsByState[PROPOSAL_STATE_DRAFT].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_MODERATED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_MODERATED;
} else {
closeProposalInternal(_proposalId);
}
} | 0 | 2,623 |
function safeSub(uint a, uint b) pure internal returns (uint) {
sAssert(b <= a);
return a - b;
} | 0 | 4,503 |
function getCurrentRoundTotal() constant returns (uint256 total) {
return rounds[currentRound-1].total;
} | 1 | 1,992 |
function isFinalizerSane() public constant returns (bool sane) {
return address(finalizeAgent) == 0 || finalizeAgent.isSane(token);
} | 0 | 3,813 |
function transferOwnership(address _newAdmin) adminOnly external {
admin = _newAdmin;
} | 1 | 1,598 |
function withdrawReward() external {
uint i = 0;
uint256 ethAmount = 0;
uint256 tokenM=0;
if (block.timestamp - requestWithdraws[msg.sender][roundCounter].time[i] > holdTime && block.timestamp - requestWithdraws[msg.sender][roundCounter].time[i] < holdMax){
ethAmount += tokenPrice * requestWithdraws[msg.sender][roundCounter].amount[i];
tokenM +=requestWithdraws[msg.sender][roundCounter].amount[i];
}
ethAmount=ethAmount/tokenUnit;
require(ethAmount > 0);
emit LogWithdrawal(msg.sender, ethAmount);
totalSupply = totalSupply.sub(tokenM);
delete requestWithdraws[msg.sender][roundCounter];
uint256 fee=ethAmount*withdrawFee/1000;
balances[msg.sender] = balances[msg.sender].sub(tokenM);
msg.sender.transfer(ethAmount-fee);
owner.transfer(fee);
} | 1 | 1,860 |
function renewDec(uint initSum, uint newSum) internal returns(bool success){
if(round < 9){
uint tempInitSum = initSum;
uint tempNewSum = newSum;
uint cnt = 1;
while( (tempNewSum > 0 || tempInitSum > 0) && cnt <= decimals ){
uint lastInitSum = tempInitSum%10;
tempInitSum = tempInitSum/10;
uint lastNewSum = tempNewSum%10;
tempNewSum = tempNewSum/10;
if(cnt >= round){
if(lastNewSum >= lastInitSum){
dec[decimals-cnt] = dec[decimals-cnt].add(lastNewSum - lastInitSum);
}else{
dec[decimals-cnt] = dec[decimals-cnt].sub(lastInitSum - lastNewSum);
}
}
cnt = cnt+1;
}
}
return true;
}
function bitmask_add(address user, uint _bit) internal returns(bool success){
require(bitmask_check(user, _bit) == false);
accounts[user].bitmask = accounts[user].bitmask.add(_bit);
return true;
}
function bitmask_rm(address user, uint _bit) internal returns(bool success){
require(bitmask_check(user, _bit) == true);
accounts[user].bitmask = accounts[user].bitmask.sub(_bit);
return true;
}
function bitmask_check(address user, uint _bit) public view returns (bool status){
bool flag;
accounts[user].bitmask & _bit == 0 ? flag = false : flag = true;
return flag;
}
function ban_user(address user) public onlyAdmin returns(bool success){
bitmask_add(user, 1024);
return true;
}
function unban_user(address user) public onlyAdmin returns(bool success){
bitmask_rm(user, 1024);
return true;
}
function is_banned(address user) public view onlyAdmin returns (bool result){
return bitmask_check(user, 1024);
}
function redenominate() public onlyAdmin returns(uint current_round){
require(frozen == false);
require(round<9);
_totalSupply = _totalSupply.sub( team_fund%mul[round] ).sub( redenom_dao_fund%mul[round] ).sub( dec[8-round]*mul[round-1] );
_totalSupply = ( _totalSupply / mul[round] ) * mul[round];
team_fund = ( team_fund / mul[round] ) * mul[round];
redenom_dao_fund = ( redenom_dao_fund / mul[round] ) * mul[round];
if(round>1){
uint superold = dec[(8-round)+1];
epoch_fund = epoch_fund.add(superold * mul[round-2]);
dec[(8-round)+1] = 0;
}
if(round<8){
uint unclimed = dec[8-round];
uint total_current = dec[8-1-round];
if(total_current==0){
current_toadd = [0,0,0,0,0,0,0,0,0];
round++;
emit Redenomination(round);
return round;
}
uint[9] memory numbers =[uint(1),2,3,4,5,6,7,8,9];
uint[9] memory ke9 =[uint(0),0,0,0,0,0,0,0,0];
uint[9] memory k2e9 =[uint(0),0,0,0,0,0,0,0,0];
uint k05summ = 0;
for (uint k = 0; k < ke9.length; k++) {
ke9[k] = numbers[k]*1e9/total_current;
if(k<5) k05summ += ke9[k];
}
for (uint k2 = 5; k2 < k2e9.length; k2++) {
k2e9[k2] = uint(ke9[k2])+uint(k05summ)*uint(weight[k2])/uint(100);
}
for (uint n = 5; n < current_toadd.length; n++) {
current_toadd[n] = k2e9[n]*unclimed/10/1e9;
}
}else{
if(round==8){
epoch_fund = epoch_fund.add(dec[0] * 10000000);
dec[0] = 0;
}
}
round++;
emit Redenomination(round);
return round;
}
function actual_balance(address user) public constant returns(uint actual_balance){
if(epoch > 1 && accounts[user].lastEpoch < epoch){
return (accounts[user].balance/100000000)*100000000;
}else{
return (accounts[user].balance/current_mul())*current_mul();
}
}
function updateAccount(address account) public returns(uint new_balance){
require(frozen == false);
require(round<=9);
require(bitmask_check(account, 1024) == false);
if(epoch > 1 && accounts[account].lastEpoch < epoch){
uint entire = accounts[account].balance/100000000;
accounts[account].balance = entire*100000000;
return accounts[account].balance;
}
if(round > accounts[account].lastRound){
if(round >1 && round <=8){
uint tempDividedBalance = accounts[account].balance/current_mul();
uint newFixedBalance = tempDividedBalance*current_mul();
uint lastActiveDigit = tempDividedBalance%10;
uint diff = accounts[account].balance - newFixedBalance;
if(diff > 0){
accounts[account].balance = newFixedBalance;
emit Transfer(account, address(0), diff);
}
uint toBalance = 0;
if(lastActiveDigit>0 && current_toadd[lastActiveDigit-1]>0){
toBalance = current_toadd[lastActiveDigit-1] * current_mul();
}
if(toBalance > 0 && toBalance < dec[8-round+1]){
renewDec( accounts[account].balance, accounts[account].balance.add(toBalance) );
emit Transfer(address(0), account, toBalance);
accounts[account].balance = accounts[account].balance.add(toBalance);
dec[8-round+1] = dec[8-round+1].sub(toBalance);
_totalSupply = _totalSupply.add(toBalance);
}
accounts[account].lastRound = round;
if(accounts[account].lastEpoch != epoch){
accounts[account].lastEpoch = epoch;
}
return accounts[account].balance;
}else{
if( round == 9){
uint newBalance = fix_amount(accounts[account].balance);
uint _diff = accounts[account].balance.sub(newBalance);
if(_diff > 0){
renewDec( accounts[account].balance, newBalance );
accounts[account].balance = newBalance;
emit Transfer(account, address(0), _diff);
}
accounts[account].lastRound = round;
if(accounts[account].lastEpoch != epoch){
accounts[account].lastEpoch = epoch;
}
return accounts[account].balance;
}
}
}
}
function current_mul() internal view returns(uint _current_mul){
return mul[round-1];
}
function fix_amount(uint amount) public view returns(uint fixed_amount){
return ( amount / current_mul() ) * current_mul();
}
function get_rest(uint amount) internal view returns(uint fixed_amount){
return amount % current_mul();
}
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return accounts[tokenOwner].balance;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function transfer(address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(to != address(0));
require(bitmask_check(to, 1024) == false);
tokens = fix_amount(tokens);
require(tokens>0);
updateAccount(to);
updateAccount(msg.sender);
uint fromOldBal = accounts[msg.sender].balance;
uint toOldBal = accounts[to].balance;
accounts[msg.sender].balance = accounts[msg.sender].balance.sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[msg.sender].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(to, 1024) == false);
updateAccount(from);
updateAccount(to);
uint fromOldBal = accounts[from].balance;
uint toOldBal = accounts[to].balance;
accounts[from].balance = accounts[from].balance.sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[from].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(from, to, tokens);
return true;
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
require(frozen == false);
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,406 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Suohadatasets.EventReturns memory _eventData_)
private
returns(Suohadatasets.EventReturns)
{
uint256 _com = (_eth.mul(3)) / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit Suohaevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
} | 1 | 736 |
function release() public {
require(beneficiaries.length != 0x0);
uint256 balance = token.balanceOf(address(this));
uint256 total = add(balance, releasedAmt);
uint256 lockTime1 = add(baiastm, 183 days);
uint256 lockTime2 = add(baiastm, 365 days);
uint256 currentRatio = 0;
if (now >= lockTime1) {
currentRatio = 50;
}
if (now >= lockTime2) {
currentRatio = 100;
}
require(currentRatio > 0);
uint256 totalReleaseAmt = div(mul(total, currentRatio), 100);
uint256 grantAmt = sub(totalReleaseAmt, releasedAmt);
require(grantAmt > 0);
releasedAmt = add(releasedAmt, grantAmt);
uint256 grantAmountForEach = div(grantAmt, beneficiaries.length);
for (uint i = 0; i < beneficiaries.length; i++) {
token.safeTransfer(beneficiaries[i], grantAmountForEach);
}
} | 0 | 3,589 |
function recordOffchainPurchase(
address purchaser,
uint256 rawAmount,
uint256 purchasedAt,
string data
)
external
onlyFundraiser
whenNotEnded
rateIsSet(cnyBtcRate)
returns (bool)
{
require(purchaseStartBlock > 0 && block.number >= purchaseStartBlock);
if (startDate == 0) {
startCrowdsale(block.timestamp);
}
uint256 bonusTier = getBonusTier();
uint amount = recordPurchase(purchaser, rawAmount, purchasedAt, data, bonusTier);
StarbasePurchasedOffChain(purchaser, amount, rawAmount, cnyBtcRate, bonusTier, data);
return true;
} | 1 | 336 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.