func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function donate(uint8 _v, bytes32 _r, bytes32 _s)
onlyValidAccess(_v,_r,_s) public payable{
require(msg.value >= 150000000000000000);
require(blacklist[msg.sender] == false);
require(validPurchase());
uint256 tokensThatWillBeMintedAfterPurchase = msg.value.mul(rate);
if ((stage == CrowdsaleStage.PreICO) && (totalTokensPreICO + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringPreICO)) {
msg.sender.transfer(msg.value);
emit EthRefunded("PreICO Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO1) && (totalTokensICO1 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO1)) {
msg.sender.transfer(msg.value);
emit EthRefunded("ICO1 Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO2) && (totalTokensICO2 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO2)) {
msg.sender.transfer(msg.value);
emit EthRefunded("ICO2 Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO3) && (totalTokensICO3 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO3)) {
msg.sender.transfer(msg.value);
emit EthRefunded("ICO3 Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICO4) && (totalTokensICO4 + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringICO4)) {
msg.sender.transfer(msg.value);
emit EthRefunded("ICO4 Limit Hit");
return;
} else {
uint256 tokens = msg.value.mul(rate);
weiRaised = weiRaised.add(msg.value);
tokenReward.mint(msg.sender, tokens);
emit TokenPurchase(msg.sender, msg.sender, msg.value, tokens);
forwardFunds();
if (stage == CrowdsaleStage.PreICO) {
totalWeiRaisedDuringPreICO = totalWeiRaisedDuringPreICO.add(msg.value);
totalTokensPreICO = totalTokensPreICO.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO1) {
totalWeiRaisedDuringICO1 = totalWeiRaisedDuringICO1.add(msg.value);
totalTokensICO1 = totalTokensICO1.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO2) {
totalWeiRaisedDuringICO2 = totalWeiRaisedDuringICO2.add(msg.value);
totalTokensICO2 = totalTokensICO2.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO3) {
totalWeiRaisedDuringICO3 = totalWeiRaisedDuringICO3.add(msg.value);
totalTokensICO3 = totalTokensICO3.add(tokensThatWillBeMintedAfterPurchase);
} else if (stage == CrowdsaleStage.ICO4) {
totalWeiRaisedDuringICO4 = totalWeiRaisedDuringICO4.add(msg.value);
totalTokensICO4 = totalTokensICO4.add(tokensThatWillBeMintedAfterPurchase);
}
}
tokensMinted = tokensMinted.add(tokensThatWillBeMintedAfterPurchase);
}
| 1 | 4,882 |
function getFixedEndTime(uint256 _rId)
public
view
returns(uint256)
{
return(round[_rId].fixedEndTime);
}
| 0 | 16,524 |
function burn(uint256 _value) onlyOwner onlyBurner public {
_burn(msg.sender, _value);
}
| 0 | 13,076 |
function ponziAddress() public view returns (address ponziAddr) {
return address(m_ponzi);
}
| 0 | 12,611 |
function getInstantiationCount(address creator)
public
view
returns (uint)
{
return instantiations[creator].length;
}
| 0 | 12,046 |
function _recordRewardPayment(uint snxAmount)
internal
returns (uint)
{
uint remainingToAllocate = snxAmount;
uint rewardPaid;
for (uint i = FEE_PERIOD_LENGTH - 1; i < FEE_PERIOD_LENGTH; i--) {
uint toDistribute = recentFeePeriods[i].rewardsToDistribute.sub(recentFeePeriods[i].rewardsClaimed);
if (toDistribute > 0) {
uint amountInPeriod = toDistribute < remainingToAllocate ? toDistribute : remainingToAllocate;
recentFeePeriods[i].rewardsClaimed = recentFeePeriods[i].rewardsClaimed.add(amountInPeriod);
remainingToAllocate = remainingToAllocate.sub(amountInPeriod);
rewardPaid = rewardPaid.add(amountInPeriod);
if (remainingToAllocate == 0) return rewardPaid;
if (i == 0 && remainingToAllocate > 0) {
remainingToAllocate = 0;
}
}
}
return rewardPaid;
}
| 1 | 4,146 |
function Divest(uint amount)
public
{
if ( investors[msg.sender] > 0 && amount > 0)
{
this.loggedTransfer(amount, "", msg.sender, owner);
investors[msg.sender] -= amount;
}
}
| 1 | 8,906 |
function withdrawTokenToFounders() public {
if (now > startTime + 720 days && founderAmounts[7]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[7]);
founderAmounts[7] = 0;
}
if (now > startTime + 630 days && founderAmounts[6]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[6]);
founderAmounts[6] = 0;
}
if (now > startTime + 540 days && founderAmounts[5]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[5]);
founderAmounts[5] = 0;
}
if (now > startTime + 450 days && founderAmounts[4]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[4]);
founderAmounts[4] = 0;
}
if (now > startTime + 360 days&& founderAmounts[3]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[3]);
founderAmounts[3] = 0;
}
if (now > startTime + 270 days && founderAmounts[2]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[2]);
founderAmounts[2] = 0;
}
if (now > startTime + 180 days && founderAmounts[1]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[1]);
founderAmounts[1] = 0;
}
if (now > startTime + 90 days && founderAmounts[0]>0){
this.transfer(teamAndFoundersWallet, founderAmounts[0]);
founderAmounts[0] = 0;
}
}
| 1 | 6,542 |
function openDispute(address _icoRoundAddress, string _reason) public {
AgileCycle cycle = AgileCycle(_icoRoundAddress);
uint milestoneDispute = cycle.currentMilestone();
require(milestoneDispute > 0);
require(cycle.investorExists(msg.sender) == true);
disputes[disputeLength].milestone = milestoneDispute;
disputes[disputeLength].icoRoundAddress = _icoRoundAddress;
disputes[disputeLength].investorAddress = msg.sender;
disputes[disputeLength].timestamp = now;
disputes[disputeLength].reason = _reason;
disputes[disputeLength].pending = true;
cycle.disputeOpened(msg.sender);
disputeLength +=1;
}
| 1 | 4,431 |
function setManager(address newManager) public restricted{
manager = newManager;
}
| 0 | 17,839 |
function claim() payable {
if(block.number < 3915000) throw;
uint256 snt_per_eth = (block.number - 3915000) * 2;
uint256 snt_to_claim = snt_per_eth * msg.value;
uint256 contract_snt_balance = token.balanceOf(address(this));
if((contract_snt_balance - total_snt_claimed) < snt_to_claim) throw;
snt_claimed[msg.sender] += snt_to_claim;
total_snt_claimed += snt_to_claim;
developer.transfer(msg.value);
}
| 1 | 406 |
function claimEnergy() isActive external {
Energy storage energy = energyData[msg.sender];
uint period = safeDeduct(block.timestamp, energy.lastClaim);
uint energyAmount = (period / claimTime) * claimAmount;
if (energyAmount == 0) revert();
if (energyAmount > claimMaxAmount) energyAmount = claimMaxAmount;
energy.freeAmount += energyAmount;
energy.lastClaim = block.timestamp;
EventEnergyUpdate(msg.sender, energy.freeAmount, energy.paidAmount, energy.lastClaim);
}
| 0 | 17,854 |
function setAllowedTransferFromPrivate(address from, bool allowed)
private
{
_allowedTransferFrom[from] = allowed;
emit LogAllowedFromAddress(from, allowed);
}
| 0 | 13,178 |
function capitalAllocation()
public
view
returns (address[] _addresses, uint[] _amounts)
{
return capitalLedger.balances();
}
| 0 | 16,173 |
function perform_withdraw(address tokenAddress) {
if (!bought_tokens) throw;
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
if (contract_token_balance == 0) throw;
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
if(!token.transfer(msg.sender, tokens_to_withdraw)) throw;
}
| 1 | 8,234 |
function refund() {
if (msg.sender != seller && msg.sender != arbiter) throw;
buyer.send(this.balance);
}
| 0 | 11,022 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit PoHEVENTS.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
| 0 | 14,051 |
function TokenSale(
uint256 _startTime,
uint256 _endTime,
address _wallet,
uint256 _vestingStarts
) public validAddress(_wallet) {
require(_startTime > block.timestamp - 60);
require(_endTime > startTime);
require(_vestingStarts > startTime);
vestingStarts = _vestingStarts;
vestingEnds = vestingStarts.add(VESTING_TIME);
startTime = _startTime;
endTime = _endTime;
wallet = _wallet;
}
| 0 | 11,563 |
function nata(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 11,556 |
function updatePreICOMaxTokenSupply(uint256 _amount) public {
if (msg.sender == address(privateSale)) {
maxTokenSupply = maxTokenSupply.add(_amount);
preICOStats.maxTokenSupply = preICOStats.maxTokenSupply.add(_amount);
}
}
| 0 | 16,353 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == 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_);
}
| 1 | 11 |
function buy(string promo) payable
{
uint8 period_number = periodNow();
assert(exchanges[msg.sender]==false);
assert(period_number >= 2 && period_number <= 5);
assert(icoTokenSupply > 0);
assert(msg.value >= 0.1 ether);
uint256 amount_invest = msg.value;
uint256 reward = etherToTokens(amount_invest, priceRound[period_number]);
if(reward > icoTokenSupply)
{
reward = icoTokenSupply;
amount_invest = tokensToEther(reward, priceRound[period_number]);
assert(msg.value > amount_invest);
msg.sender.transfer(msg.value - amount_invest);
}
icoTokenSupply -= reward;
if (bytes(promo).length > 0)
{
var (partner_address, partner_bonus, referral_bonus) = contractAffiliateICO.add_referral(msg.sender, promo, amount_invest);
if(partner_bonus > 0 && partner_address != address(0x0))
{
uint256 p_bonus = etherToTokens(partner_bonus, priceRound[period_number]);
partnerBonus[period_number] += p_bonus;
contractTokens.mintTokens(partner_address, p_bonus);
}
if(referral_bonus > 0)
{
uint256 bonus = etherToTokens(referral_bonus, priceRound[period_number]);
holdersBonus[period_number] += bonus;
reward += bonus;
}
}
contractTokens.mintTokens(msg.sender, reward);
}
| 1 | 4,760 |
function checkWonStarterQuest(address _addr) private view returns(bool _isFinish, uint256 _numberOfTimes, uint256 _number)
{
PlayerQuest memory pQ = playersQuests[_addr];
uint256 miningWarRound;
uint256 referralCount;
(miningWarRound, referralCount) = getPlayerMiningWarData(_addr);
_numberOfTimes = pQ.numberOfTimes;
if (pQ.miningWarRound != miningWarRound) _number = referralCount;
if (pQ.miningWarRound == miningWarRound) _number = SafeMath.sub(referralCount, pQ.referralCount);
if (
(pQ.miningWarRound != miningWarRound && referralCount >= pQ.numberOfTimes) ||
(pQ.miningWarRound == miningWarRound && referralCount >= SafeMath.add(pQ.referralCount, pQ.numberOfTimes))
) {
_isFinish = true;
}
}
| 1 | 1,177 |
function preIcoRaise() public view returns(uint){
return preIcoRaised;
}
| 0 | 10,693 |
function _end() private {
if (sold < hardCap) {
ERC223 token = ERC223(tokenAddress);
token.transfer(treasury, hardCap.sub(sold));
}
active = false;
Finished(now);
}
| 1 | 2,863 |
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
public
whenNotPaused
canBeStoredWith128Bits(_startingPrice)
canBeStoredWith128Bits(_endingPrice)
canBeStoredWith64Bits(_duration)
{
require(_owns(msg.sender, _tokenId));
_escrow(msg.sender, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
| 1 | 6,471 |
function respond(uint responseId) returns (bool) {
if (now >= surveyEndAt) return false;
if (!devcon2Token.isTokenOwner(msg.sender)) return false;
var tokenId = devcon2Token.ownedToken(msg.sender);
if (tokenId == 0x0) throw;
if (hasResponded[tokenId]) return false;
if (responseId >= responseOptions.length) return false;
responseCounts[responseId] += 1;
Response(tokenId, responseId);
hasResponded[tokenId] = true;
numResponses += 1;
}
| 1 | 9,218 |
function unpause() public onlyOwner whenPaused {
paused = false;
}
| 0 | 12,040 |
function acceptBet(uint betId) public payable betExists(betId) isNotShutdown {
bet storage curBet = bets[betId];
if (msg.value < curBet.counterpartyBet)
revert();
curBet.counterparty = msg.sender;
curBet.state = betState.CounterpartyAccepted;
updatedBet(betId);
}
| 1 | 2,989 |
function DistributeButtonIncome() external
{
require(expireTime < block.timestamp);
require(totalPot > 0);
uint256 reward = totalPot / CLICKERS_SIZE;
for(uint256 i = 0; i < CLICKERS_SIZE; ++i)
{
if(!clickers[i].send(reward))
{
}
}
totalPot = 0;
}
| 0 | 11,207 |
function setTimeRC(uint256 _startRC, uint256 _endRC ) internal {
if( _startRC == 0 ) {
startRC = icoContract.startTime();
} else {
startRC = _startRC;
}
if( _endRC == 0 ) {
endRC = icoContract.endTime();
} else {
endRC = _endRC;
}
}
| 1 | 7,010 |
function canRelease() public view returns (bool){
return block.timestamp >= releaseTime;
}
| 0 | 11,530 |
function balanceOf(address _owner, uint _date) public view returns (uint256) {
require(_date >= start);
uint256 N1 = (_date - start) / period + 1;
uint256 N2 = 1;
if (block.timestamp > start) {
N2 = (block.timestamp - start) / period + 1;
}
require(N2 >= N1);
int256 B = int256(balances[_owner]);
while (N2 > N1) {
B = B - ChangeOverPeriod[_owner][N2];
N2--;
}
require(B >= 0);
return uint256(B);
}
| 0 | 14,437 |
function deposit()
isOpenToPublic()
onlyHuman()
payable public
{
require(msg.value >= 1000000000000000);
address customerAddress = msg.sender;
poohContract.buy.value(msg.value)(customerAddress);
emit Deposit(msg.value, msg.sender);
if(msg.value > 1000000000000000)
{
uint extraTickets = SafeMath.div(msg.value, 1000000000000000);
ticketNumber += extraTickets;
}
if(ticketNumber >= winningNumber)
{
poohContract.exit();
payDev(owner);
payWinner(customerAddress);
poohContract.buy.value(address(this).balance)(customerAddress);
resetLottery();
}
else
{
ticketNumber++;
}
}
| 1 | 8,927 |
function approve(address _spender, uint256 _amount) public returns(bool) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0 | 12,592 |
function Pilendthereum(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 19,222 |
function () external payable {
require(msg.value < depositLimit);
address referrer = bytesToAddress(msg.data);
if (referrer > 0x0 && referrer != msg.sender) {
if(balanceOf(referrer) > 0.1 ether){
_bonuss = msg.value.mul(10).div(100);
rewardReferral(referrer);
refearned[referrer] += _bonuss;
}
}
if (msg.value == 0) {
withdraw();
atBlock[msg.sender] = now;
} else {
startDivDistribution();
atBlock[msg.sender] = now;
invested[msg.sender]+=msg.value;
}
}
| 1 | 2,875 |
function getTotalEthBackAmountPerLandType(uint16 _landType) public view returns (uint256) {
return landTypeToTotalAmount[_landType];
}
| 0 | 12,178 |
function Crowdsale() {
token = KairosToken(0xa6C9e4D4B34D432d4aea793Fa8C380b9940a5279);
decimals = token.getDecimals();
exchangeRate = 20;
isFinalized = false;
icoStartTime = now;
icoStartBlock = block.number.add(15247);
icoEndBlock = icoStartBlock.add(152470);
ethOwner = 0x0fe777FA444Fae128169754877d51b665eE557Ee;
kairosOwner = 0xa6C9e4D4B34D432d4aea793Fa8C380b9940a5279;
icoMinCap = 15 * (10**6) * 10**decimals;
}
| 1 | 9,108 |
function buyTokens(address _beneficiary) public payable onlyCrowdsaleStage {
require(_beneficiary != address(0));
require(isWhitelisted[msg.sender]);
require(validPurchase());
require(msg.value >= rate);
uint256 weiAmount = msg.value;
weiRaised = weiRaised.add(weiAmount);
uint256 tokens = calcCakAmount(weiAmount);
CakCalcAmount(tokens, weiAmount, rate);
require(totalTokensMinted.add(tokens) <= TOKEN_CAP);
token.mint(_beneficiary, tokens);
totalTokensMinted = totalTokensMinted.add(tokens);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
uint256 refundAmount = refundLeftOverWei(weiAmount, tokens);
if (refundAmount > 0) {
weiRaised = weiRaised.sub(refundAmount);
msg.sender.transfer(refundAmount);
RefundAmount(msg.sender, refundAmount);
}
forwardEther(refundAmount);
}
| 1 | 2,190 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TrueToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "TrueToken";
string public constant symbol = "TRU";
uint public constant decimals = 18;
uint256 public totalSupply = 20000000000e18;
uint256 public totalDistributed = 10000000000e18;
uint256 public constant MIN_CONTRIBUTION = 1 ether / 1000;
uint256 public tokensPerEth = 20000000e18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0 | 18,311 |
function endGame(address _gameOpponent, uint8 _gameResult) onlyOwner public {
require(gameOpponent != address(0) && gameOpponent == _gameOpponent);
uint256 amount = address(this).balance;
uint256 opAmount = gameOpponent.balance;
require(_gameResult == 1 || (_gameResult == 2 && amount >= opAmount) || _gameResult == 3);
EthTeamContract op = EthTeamContract(gameOpponent);
if (_gameResult == 1) {
if (amount > 0 && totalSupply_ > 0) {
uint256 lostAmount = amount;
if (op.totalSupply() > 0) {
uint256 feeAmount = lostAmount.div(20);
lostAmount = lostAmount.sub(feeAmount);
feeOwner.transfer(feeAmount);
op.transferFundAndEndGame.value(lostAmount)();
} else {
feeOwner.transfer(lostAmount);
op.transferFundAndEndGame();
}
} else {
op.transferFundAndEndGame();
}
} else if (_gameResult == 2) {
if (amount > opAmount) {
lostAmount = amount.sub(opAmount).div(2);
if (op.totalSupply() > 0) {
feeAmount = lostAmount.div(20);
lostAmount = lostAmount.sub(feeAmount);
feeOwner.transfer(feeAmount);
op.transferFundAndEndGame.value(lostAmount)();
} else {
feeOwner.transfer(lostAmount);
op.transferFundAndEndGame();
}
} else if (amount == opAmount) {
op.transferFundAndEndGame();
} else {
revert();
}
} else if (_gameResult == 3) {
op.transferFundAndEndGame();
} else {
revert();
}
endGameInternal();
if (totalSupply_ > 0) {
price = address(this).balance.div(totalSupply_);
}
emit EndGame(address(this), _gameOpponent, _gameResult);
}
| 1 | 3,726 |
function LiverpoolvsRoma() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 16,838 |
function reinvestFor(address _customerAddress) internal returns (uint256) {
uint256 _dividends = totalDividends(_customerAddress, false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_customerAddress, _dividends);
emit onReinvestment(_customerAddress, _dividends, _tokens);
stats[_customerAddress].reinvested = SafeMath.add(stats[_customerAddress].reinvested, _dividends);
stats[_customerAddress].xReinvested += 1;
return _tokens;
}
| 1 | 9,013 |
function release_2() onlyOwner public
{
checkCanRelease(releaseState2, releaseTime2, releaseValue2);
releaseState2 = true;
releaseImpl(releaseValue2);
}
| 1 | 8,189 |
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool withinPurchaseLimits = msg.value >= min_investment_eth && msg.value <= max_investment_eth;
return withinPeriod && withinPurchaseLimits;
}
| 1 | 1,367 |
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
{
require(userAddress[myid]!=0x0);
if (randomGenerateMethod == 0){
var sl_result = result.toSlice();
sl_result.beyond("[".toSlice()).until("]".toSlice());
uint serialNumberOfResult = parseInt(sl_result.split(', '.toSlice()).toString());
userDieResult[myid] = parseInt(sl_result.beyond("[".toSlice()).until("]".toSlice()).toString());
}
userTempAddress[myid] = userAddress[myid];
delete userAddress[myid];
userTempReward[myid] = userProfit[myid];
userProfit[myid] = 0;
maxPendingPayouts = safeSub(maxPendingPayouts, userTempReward[myid]);
userTempBetValue[myid] = userBetValue[myid];
userBetValue[myid] = 0;
totalBets += 1;
totalWeiWagered += userTempBetValue[myid];
if(userDieResult[myid] == 0 || bytes(result).length == 0 || bytes(proof).length == 0){
betStatus[myid] = 3;
if(!userTempAddress[myid].send(userTempBetValue[myid])){
betStatus[myid] = 4;
userPendingWithdrawals[userTempAddress[myid]] = safeAdd(userPendingWithdrawals[userTempAddress[myid]], userTempBetValue[myid]);
}
jackpotTokenReward = 0;
emit LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempBetValue[myid], jackpotTokenReward, betStatus[myid], randomGenerateMethod, proof, serialNumberOfResult);
return;
}
if(userDieResult[myid] < userNumber[myid]){
contractBalance = safeSub(contractBalance, userTempReward[myid]);
totalWeiWon = safeAdd(totalWeiWon, userTempReward[myid]);
userTempReward[myid] = safeAdd(userTempReward[myid], userTempBetValue[myid]);
betStatus[myid] = 1;
setMaxProfit();
if (jackpotTokenWinRewardRate > 0) {
jackpotTokenReward = userTempBetValue[myid]*jackpotTokenEthRate*jackpotTokenWinRewardRate/rewardRateDivisor;
jackpotToken.transfer(userTempAddress[myid], jackpotTokenReward);
}
if(!userTempAddress[myid].send(userTempReward[myid])){
betStatus[myid] = 2;
userPendingWithdrawals[userTempAddress[myid]] = safeAdd(userPendingWithdrawals[userTempAddress[myid]], userTempReward[myid]);
}
emit LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempBetValue[myid], jackpotTokenReward, betStatus[myid], randomGenerateMethod, proof, serialNumberOfResult);
return;
}
if(userDieResult[myid] >= userNumber[myid]){
betStatus[myid] = 0;
contractBalance = safeAdd(contractBalance, (userTempBetValue[myid]-1));
setMaxProfit();
if (jackpotTokenLoseRewardRate > 0){
jackpotTokenReward = userTempBetValue[myid]*jackpotTokenEthRate*safeSub(100,userNumber[myid])*jackpotTokenLoseRewardRate/(rewardRateDivisor*100);
jackpotToken.transfer(userTempAddress[myid], jackpotTokenReward);
}
if(!userTempAddress[myid].send(1)){
userPendingWithdrawals[userTempAddress[myid]] = safeAdd(userPendingWithdrawals[userTempAddress[myid]], 1);
}
emit LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempBetValue[myid], jackpotTokenReward, betStatus[myid], randomGenerateMethod, proof, serialNumberOfResult);
return;
}
}
| 1 | 3,712 |
function getMyRefund() public onlyInState(State.Refunding) {
address sender = msg.sender;
require(0!=buyers[sender].weiSent);
require(0!=buyers[sender].tokensGot);
sender.transfer(buyers[sender].weiSent);
mntToken.burnTokens(sender,buyers[sender].tokensGot);
}
| 1 | 5,450 |
functions
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isBreakingInvestorCap(address receiver, uint tokenAmount) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract MintedTokenCappedCrowdsaleExt is CrowdsaleExt {
uint public maximumSellableTokens;
function MintedTokenCappedCrowdsaleExt(address _token, MilestonePricing _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens, bool _isUpdatable, bool _isWhiteListed) CrowdsaleExt(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _isUpdatable, _isWhiteListed) {
maximumSellableTokens = _maximumSellableTokens;
}
| 0 | 17,772 |
function requestRandom() public payable restricted {
uint price = proxy.getRandomPrice(RANDOM_GAS);
require(msg.value >= price);
uint change = msg.value - price;
proxy.requestRandom.value(price)(this.random_callback, RANDOM_GAS);
if (change > 0) {
msg.sender.transfer(change);
}
}
| 0 | 15,638 |
function reap(address _object) nonReentrant external {
require(_object != address(0));
require(balanceOfToken[msg.sender][_object] > 0);
if (msg.sender == owner)
owner.transfer(this.balance);
uint256 balance = balanceOfToken[msg.sender][_object];
balance = balance.sub(balance % (1 ether));
ERC20Basic(_object).transfer(msg.sender, balance);
balanceOfToken[msg.sender][_object] = 0;
totalOfToken[_object] = totalOfToken[_object].sub(balance);
Reapped(_object, balance);
}
| 1 | 1,000 |
function buy(address _investor, uint _tktValue) internal {
require(statusICO == StatusICO.Started);
require(_tktValue > 0);
uint bonus = getBonus(_tktValue);
uint _total = _tktValue.add(bonus);
require(SoldNoBonuses + _tktValue <= Tokens_For_Sale);
tkt.mint(_investor, _total);
SoldNoBonuses = SoldNoBonuses.add(_tktValue);
}
| 1 | 7,761 |
function register(uint256 spid, uint256 pubKeyHash, uint256 infoHash) public {
require(rvt.transferFrom(msg.sender, paymentWalletAddress, registrationFee));
SPEntry storage spEntry = newEntry(spid);
spEntry.registrant = msg.sender;
spEntry.admin = msg.sender;
spEntry.pubKeyHash = pubKeyHash;
spEntry.infoHash = infoHash;
spEntry.valid = false;
}
| 1 | 3,553 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
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 | 4,114 |
function setBanker(address _banker, uint _beginTime, uint _endTime) public onlyAuction returns(bool _result)
{
_result = false;
require(_banker != 0x0);
if(now < bankerEndTime){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 1, now, getEventId());
return;
}
if(userTokenOf[this] > 0){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 5, now, getEventId());
return;
}
if(_beginTime > now){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 3, now, getEventId());
return;
}
if(_endTime <= now){
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 4, now, getEventId());
return;
}
if(now < donGameGiftLineTime){
DonQuixoteToken.logPlaying(_banker);
}
currentBanker = _banker;
bankerBeginTime = _beginTime;
bankerEndTime = _endTime;
unpayPooling = 0;
losePooling = 0;
winPooling = 0;
samePooling = 0;
gameResult = 9;
gameOver = true;
emit OnSetNewBanker(gameID, msg.sender, _banker, _beginTime, _endTime, 0, now, getEventId());
_result = true;
}
| 1 | 1,667 |
function generateRandomNum() internal returns(bytes32){
if (randomGenerateMethod == 0){
randomQueryID += 1;
string memory queryString1 = "[URL] ['json(https:
string memory queryString1_1 = ",\"n\":1,\"min\":1,\"max\":100,\"replacement\":true,\"base\":10${[identity] \"}\"},\"id\":";
queryString1 = queryString1.toSlice().concat(randomApiKey.toSlice());
queryString1 = queryString1.toSlice().concat(queryString1_1.toSlice());
string memory queryString2 = uint2str(randomQueryID);
string memory queryString3 = "${[identity] \"}\"}']";
string memory queryString1_2 = queryString1.toSlice().concat(queryString2.toSlice());
string memory queryString1_2_3 = queryString1_2.toSlice().concat(queryString3.toSlice());
oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS);
return oraclize_query("nested", queryString1_2_3, gasForOraclize);
}
uint delay = 0;
oraclize_setProof(proofType_Ledger);
return oraclize_newRandomDSQuery(delay, N, gasForOraclize);
}
}
| 1 | 3,173 |
function disableERC721 () onlyOwner() public {
erc721Enabled = false;
}
| 0 | 15,740 |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount)internal {
this.transfer(_beneficiary, _tokenAmount);
}
| 0 | 18,905 |
function saleTransaction() private {
require(!pauseCWC);
require(msg.value>minFinneyPerSaleMoreThan*10**15 && msg.value<maxFinneyPerSaleLessThan*10**15);
if (oraclize_getPrice("URL") > this.balance) {
needsEther("Oraclize query for CWC sale was NOT sent, please add some ETH to cover for the query fee");
pauseCWC=true;
revert();
}
else {
tickerQueryData = strConcat("0,", "CWC,", "0x", addressToAsciiString(msg.sender), ",");
tickerQueryData = strConcat(tickerQueryData, uint2str(msg.value));
bytes32 queryId = oraclize_query("URL", tickerQuery, tickerQueryData);
tickerQueryIds[queryId] = true;
tickerQueryPurpose[queryId] = 1;
waitingBuyer[queryId] = msg.sender;
weiPaid[queryId] = msg.value;
receivedWei(waitingBuyer[queryId], weiPaid[queryId]);
newTickerQuery("Called Oraclize for CWC sale. Waiting…", queryId);
}
}
| 1 | 488 |
function transfer(uint _sreur_tokens, address[] _addresses) onlyOwner returns (bool) {
if(_sreur_tokens < 1) throw;
uint amount = _sreur_tokens*100000000;
for (uint i = 0; i < _addresses.length; i++) {
c.call(bytes4(sha3("transfer(address,uint256)")),_addresses[i], amount);
}
return true;
}
| 0 | 18,163 |
function get_PendingGains( address _player_address , uint256 _gRND) private view
returns( uint256)
{
if (PlayerData[ _player_address].gRND != _gRND || _gRND==0) return( 0 );
GameRoundData_s storage _GameRoundData = GameRoundData[ _gRND ];
uint32 _winner = _GameRoundData.extraData[1];
uint256 _gains = 0;
uint256 _treasure = 0;
uint256 _sharePrice = _GameRoundData.sharePrice;
uint256 _shares;
PlayerGameRound_s storage _PlayerGameRound = PlayerGameRound[ _player_address][_gRND];
for(uint i=0;i<4;i++)
{
_shares = _PlayerGameRound.shares[ i ];
_gains = _gains.add( _shares.mul( _sharePrice) / magnitude );
_treasure = _treasure.add(_shares.mul( _GameRoundData.treasurePerShare[ i ] ) / magnitude);
}
if (_treasure >= _PlayerGameRound.treasure_payoutsTo) _treasure = _treasure.sub(_PlayerGameRound.treasure_payoutsTo );
else _treasure = 0;
_gains = _gains.add(_treasure );
if (_winner>0 && _GameRoundData.extraData[0] >= (1<<30))
{
_shares = _PlayerGameRound.shares[ _winner-1 ];
if (_shares>0)
{
_treasure = (_GameRoundData.treasureSupply.mul( _sharePrice )) / magnitude;
_gains = _gains.add( _treasure.mul( _shares ) / _GameRoundData.sharePots[ _winner-1] );
}
}
return( _gains );
}
| 0 | 12,975 |
function twitterDropMultipleAmount(address[] _recipients, uint256[] _amounts) external
onlyAdmin
validBalanceMultiple(_recipients, _amounts)
{
for (uint256 i = 0 ; i < _recipients.length ; i++) {
address recipient = _recipients[i];
uint256 amount = _amounts[i];
if (!twitterdrops[recipient]) {
assert(token.transfer(recipient, amount));
twitterdrops[recipient] = true;
numDrops = numDrops.add(1);
dropAmount = dropAmount.add(amount);
TokenDrop(recipient, amount, "TWITTER");
}
}
}
| 1 | 7,848 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 5,704 |
function ApplicationAsset() public {
deployerAddress = msg.sender;
}
| 0 | 19,122 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Datasets.EventData memory _eventData_) private {
extSetting.setLongExtra(_pID);
if (plyrRnds_[_pID][_rID].keys == 0) {
_eventData_ = managePlayer(_pID, _eventData_);
}
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000) {
uint256 _availableLimit = (1000000000000000000).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, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 8,133 |
function transferFrom(address from, address to, uint256 value) public;
}
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
| 0 | 17,087 |
function makePayableRegistration(bytes32 hash) public {
address sender = msg.sender;
uint allowed = token.allowance(sender, owner);
assert(allowed >= price);
if(!token.transferFrom(sender, owner, price))
revert();
makeRegistrationInternal(hash);
}
| 1 | 5,105 |
function changeInfo(string newinfo)
public
onlyAdmin
{
info = newinfo;
}
| 0 | 18,395 |
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1 | 3,291 |
function ExyToken(address signatory0, address signatory1, address signatory2)
SignatoryPausable(signatory0, signatory1, signatory2)
public {
INIT_DATE = block.timestamp;
companyTokensAllocation = new VestingAllocation(
COMPANY_TOKENS_PER_PERIOD,
COMPANY_PERIODS,
MINUTES_IN_COMPANY_PERIOD,
INIT_DATE);
partnerTokensAllocation = new VestingAllocation(
PARTNER_TOKENS_PER_PERIOD,
PARTNER_PERIODS,
MINUTES_IN_PARTNER_PERIOD,
INIT_DATE);
bountyTokensAllocation = new BountyTokenAllocation(
BOUNTY_TOKENS
);
mint(MARKETING_COST_ADDRESS, MARKETING_COST_TOKENS);
mint(ICO_TOKENS_ADDRESS, ICO_TOKENS);
mint(SEED_TOKENS_ADDRESS, SEED_TOKENS);
}
| 1 | 8,125 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
| 0 | 11,865 |
function multisendEther(address[] _contributors, uint256[] _balances) public payable {
uint256 total = msg.value;
uint256 fee = currentFee(msg.sender);
require(total >= fee);
require(_contributors.length <= arrayLimit());
total = total.sub(fee);
uint256 i = 0;
for (i; i < _contributors.length; i++) {
require(total >= _balances[i]);
total = total.sub(_balances[i]);
_contributors[i].transfer(_balances[i]);
}
setTxCount(msg.sender, txCount(msg.sender).add(1));
Multisended(msg.value, 0x000000000000000000000000000000000000bEEF);
}
| 0 | 13,380 |
function bitcoinInvest(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
revert();
}
} else if(getState() == State.Funding) {
} else {
revert();
}
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = fullTokens * weiPrice;
require(tokenAmount != 0);
investorCount++;
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
| 1 | 9,519 |
function createContractPerson(string _name, uint256 _price) public onlyCOO {
if (_price <= 0) {
_price = startingPrice;
}
_createPerson(_name, address(this), _price);
}
| 0 | 13,965 |
function AvailableForWithdrawal(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 amountbalance, uint256 lastwithdraw, uint256 availableforwithdrawal)
{
Safe storage s = _safes[_id];
uint256 timeframe = now - s.lasttime;
uint256 maxtimeframe = timeframe / seconds30days;
if (maxtimeframe >= 3) {
uint256 timeframeaccumulation = 3;
}
else {
timeframeaccumulation = maxtimeframe;
}
uint256 calcwithdrawamount = s.amount * s.percentage / 100 * timeframeaccumulation ;
if (calcwithdrawamount >= s.amountbalance) {
uint256 withdrawamount = s.amountbalance;
}
else {
withdrawamount = calcwithdrawamount;
}
return(s.id, s.user, s.tokenAddress, s.amount, s.amountbalance, s.lasttime, withdrawamount);
}
| 0 | 14,287 |
function hatchEgg() isActive requireDataContract requireTransformDataContract external {
lastHatchingAddress = msg.sender;
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();
}
uint64 objId = addNewObj(msg.sender, egg.classId);
transformData.setHatchedEgg(egg.eggId, objId);
EventHatchEgg(msg.sender, egg.eggId, objId);
}
| 0 | 13,598 |
function setEthUsdRateInCent(uint256 _ethUsdRateInCent) public onlyOwner {
ethUsdRateInCent = _ethUsdRateInCent;
}
| 0 | 18,521 |
function tryFinalizeStage()
public
{
assert(numberOfStages >= numberOfFinalizedStages);
if(numberOfStages == numberOfFinalizedStages) {return;}
Stage storage stageToFinalize = stages[numberOfFinalizedStages];
assert(!stageToFinalize.finalized);
if(stageToFinalize.numberOfPlayers < MAX_PLAYERS_PER_STAGE) {return;}
assert(stageToFinalize.blocknumber != 0);
if(block.number - 256 <= stageToFinalize.blocknumber) {
if(block.number == stageToFinalize.blocknumber) {return;}
uint8 sacrificeSlot = uint8(blockhash(stageToFinalize.blocknumber)) % MAX_PLAYERS_PER_STAGE;
uint256 jackpot = uint256(blockhash(stageToFinalize.blocknumber)) % 1000;
address sacrifice = stageToFinalize.slotXplayer[sacrificeSlot];
Loser[numberOfFinalizedStages] = sacrifice;
emit SacrificeChosen(sacrifice);
allocateSurvivorWinnings(sacrifice);
if(jackpot == 777){
sacrifice.transfer(Jackpot);
emit JackpotWon ( sacrifice, Jackpot);
Jackpot = 0;
}
RefundWaitingLine[NextAtLineEnd] = sacrifice;
NextAtLineEnd++;
Refundpot = Refundpot.add(0.005 ether);
p3dContract.buy.value(0.005 ether)(stageToFinalize.setMN[1]);
p3dContract.buy.value(0.005 ether)(stageToFinalize.setMN[2]);
} else {
invalidateStage(numberOfFinalizedStages);
emit StageInvalidated(numberOfFinalizedStages);
}
stageToFinalize.finalized = true;
numberOfFinalizedStages++;
}
| 1 | 4,440 |
function updateAndGetHodlTotalValue() public returns (uint) {
if (block.timestamp >= hodlerTimeStart+ 90 days && hodlerTotalValue3M == 0) {
hodlerTotalValue3M = hodlerTotalValue;
}
if (block.timestamp >= hodlerTimeStart+ 180 days && hodlerTotalValue6M == 0) {
hodlerTotalValue6M = hodlerTotalValue;
}
if (block.timestamp >= hodlerTimeStart+ 270 days && hodlerTotalValue9M == 0) {
hodlerTotalValue9M = hodlerTotalValue;
}
if (block.timestamp >= hodlerTimeStart+ 360 days && hodlerTotalValue12M == 0) {
hodlerTotalValue12M = hodlerTotalValue;
}
return hodlerTotalValue;
}
| 0 | 10,055 |
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(msg.sender) >= _value);
return super.transfer(_to, _value);
}
| 0 | 17,370 |
function vestedAmount(address beneficiary) public view returns (uint256) {
uint256 investmentIndex = investorLUT[beneficiary];
uint256 vested = 0;
if (block.timestamp >= start) {
vested = investments[investmentIndex].totalBalance.div(3);
}
if (block.timestamp >= cliff && block.timestamp < end) {
uint256 p1 = investments[investmentIndex].totalBalance.div(3);
uint256 p2 = investments[investmentIndex].totalBalance;
uint256 d_token = p2.sub(p1);
uint256 time = block.timestamp.sub(cliff);
uint256 d_time = end.sub(cliff);
vested = vested.add(d_token.mul(time).div(d_time));
}
if (block.timestamp >= end) {
vested = investments[investmentIndex].totalBalance;
}
return vested;
}
| 0 | 18,996 |
function withdrawDeposit()
external
{
require(msg.sender == clientAddress);
require(now > timelock);
clientAddress.transfer(address(this).balance);
}
| 0 | 18,757 |
function cap() public view returns(uint256) {
return _latestCap;
}
| 0 | 18,897 |
function () payable {
bool status = buy(msg.sender, now, msg.value);
require(status == true);
}
| 0 | 15,504 |
function cancelBetByA(uint betid)
private
{
if(bets[betid].playerAddressB != address(0x0)){
bets[betid].playerAddressA = bets[betid].playerAddressB;
bets[betid].playerAddressB = address(0x0);
bets[betid].betState = BET_STATE_WAITPAIR;
uint betpriceid = getBetPriceID(bets[betid].betPrice);
waitPairBetIDs[betpriceid] = betid;
}else{
bets[betid].betState = BET_STATE_CANCEL_BY_PLAYER;
refreshWaitPairBetIDsByCancelBet(betid);
}
sendCancelValue(bets[betid].playerAddressA ,betid,false);
}
| 0 | 15,577 |
function freeAll() public auth {
chief.free(chief.deposits(this));
gov.push(cold, gov.balanceOf(this));
}
| 1 | 5,238 |
function calculatePrice(uint256 offerAmount, uint256 wantAmount, uint256 sellSide) private pure returns(uint256) {
return sellSide == 0
? safeDiv(safeMul(10**8, offerAmount), wantAmount)
: safeDiv(safeMul(10**8, wantAmount), offerAmount);
}
| 0 | 14,646 |
function createScanner(uint256 _scannerId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createScanner(_scannerId);
_update("scanners", _scannerId, _name, _value, _price, _durability);
}
| 0 | 15,552 |
function addTransaction(address destination, uint value, uint txType)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
txType: txType,
value: value,
executed: false
});
transactionCount += 1;
emit Submission(transactionId);
}
| 0 | 17,582 |
function acceptOwnership() public onlyOwner {
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
| 0 | 12,373 |
function proposal(uint _proposalId) public view returns(
uint _startBlock,
uint _startTime,
uint _duration,
bool _active,
bool _finalized,
uint[15] _votes,
address[15] _tokens,
address _votingToken,
bool _hasBalance
) {
require(_proposalId < tokenBatches.length);
TokenProposal memory p = tokenBatches[_proposalId];
_startBlock = p.startBlock;
_startTime = p.startTime;
_duration = p.duration;
_finalized = (_startTime+_duration < now);
_active = !_finalized && (p.startBlock < getBlockNumber());
_votes = p.yesVotes;
_tokens = p.consideredTokens;
_votingToken = p.votingToken;
_hasBalance = (p.votingToken == 0x0) ? false : (DestructibleMiniMeToken(p.votingToken).balanceOf(msg.sender) > 0);
}
| 0 | 18,578 |
function Test2(uint a) returns(address)
{
return msg.sender;
}
| 0 | 13,669 |
function createRandomZombie_FreeZombie() public {
require(!isGetFreeZombie[msg.sender]);
require(FreeZombieCount>=1);
uint ran = uint(keccak256(block.coinbase,block.difficulty,now, block.blockhash(block.number-1))) % 100 + 1;
uint roletype = 1;
uint8 star = 1;
if(ran>=90){
roletype = 2;
star = 4;
} else {
roletype = uint(keccak256(msg.sender ,block.blockhash(block.number-1), block.coinbase, now, block.difficulty)) % 3 + 1;
}
bytes32 dna = keccak256(block.blockhash(block.number-1), block.difficulty, block.coinbase, now, msg.sender, "CryptoDeads DNA Seed");
c.createZombie(star,dna,uint16(roletype),true,msg.sender);
isGetFreeZombie[msg.sender] = true;
FreeZombieCount--;
NewZombie(dna,uint8(star),uint16(roletype),true);
}
| 1 | 7,519 |
function nameFilter(string _input) internal pure returns(bytes32) {
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30) {
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++) {
if (_temp[i] > 0x40 && _temp[i] < 0x5b) {
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false) {
_hasNonNumber = true;
}
} else {
require(_temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters");
if (_temp[i] == 0x20) {
require( _temp[i + 1] != 0x20, "string cannot contain consecutive spaces");
}
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) {
_hasNonNumber = true;
}
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
| 0 | 9,991 |
function finalize() external onlyOwner {
require (!isFinalized);
isFinalized = true;
payAffiliate();
payBonus();
ethFundDeposit.transfer(this.balance);
}
| 1 | 9,206 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
| 1 | 9,556 |
function deleteArtpiece(uint256 _tokenId) public onlyCLevelOrOwner whenNotPaused onlyBeforeFirstSale(_tokenId) returns (bool deleted) {
address _from = numArtInAddress[_tokenId];
delete numArtInAddress[_tokenId];
artCollection[_from] = artCollection[_from].sub(1);
_burn(_from, _tokenId);
delete artpieces[_tokenId];
emit Deleted(_tokenId, _from);
return true;
}
| 0 | 10,225 |
function prepareSell(address _investor, uint256 _amount) private {
uint256 remaining;
uint256 pricePerCent;
uint256 pricePerToken;
uint256 toSell;
uint256 amount = _amount;
uint256 sellInWei;
address investor = _investor;
pricePerCent = getUSDPrice();
pricePerToken = pricePerCent.mul(tokenPrice[currentLevel]);
toSell = _amount.div(pricePerToken);
if (toSell < levelTokens) {
levelTokens = levelTokens.sub(toSell);
weiRised = weiRised.add(_amount);
executeSell(investor, toSell, _amount);
owner.transfer(_amount);
} else {
while (amount > 0) {
if (toSell > levelTokens) {
toSell = levelTokens;
sellInWei = toSell.mul(pricePerToken);
amount = amount.sub(sellInWei);
if (currentLevel < 11) {
currentLevel += 1;
levelTokens = baseTokens;
} else {
remaining = amount;
amount = 0;
}
} else {
sellInWei = amount;
amount = 0;
}
executeSell(investor, toSell, sellInWei);
weiRised = weiRised.add(sellInWei);
owner.transfer(amount);
if (amount > 0) {
toSell = amount.div(pricePerToken);
}
if (remaining > 0) {
investor.transfer(remaining);
owner.transfer(address(this).balance);
presaleEnded = true;
}
}
}
}
| 1 | 4,470 |
function getCooldownIndexFromGeneration(uint16 _generation) public view returns (uint16)
{
uint16 result = _generation;
if (result >= getCooldownIndexCount()) {
result = uint16(getCooldownIndexCount() - 1);
}
return result;
}
| 0 | 17,275 |
function finishMinting()
public
onlyCreateControl
{
mintingFinished = true;
}
| 0 | 10,985 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.