func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function newPeriod(uint256 _ownerCut) public onlyOwner {
require(now >= epoch + 15 days);
require(_ownerCut <= 10000);
uint256 unclaimedDividend = dividendPool;
uint256 ownerRake = (address(this).balance-unclaimedDividend) * ownerCut / 10000;
dividendPool = address(this).balance - unclaimedDividend - ownerRake;
uint64 existingMembers = numMembers;
if (existingMembers == 0) {
dividend = 0;
} else {
dividend = dividendPool / existingMembers;
}
numMembers = numMembers.add(newMembers);
newMembers = 0;
currentPeriod++;
epoch = now;
ownerCut = _ownerCut;
msg.sender.transfer(ownerRake + unclaimedDividend);
PeriodEnd(currentPeriod-1, this.balance, existingMembers);
}
| 0 | 11,744 |
function totalDistributedTokens() public view returns (uint256) {
return _totalDistributedTokens;
}
| 0 | 16,991 |
function withdraw() {
if (contributor_rounds[msg.sender] < rounds) {
uint256 balance = contr.balances_bonus(msg.sender);
Snapshot storage snapshot = snapshots[contributor_rounds[msg.sender]];
uint256 tokens_to_withdraw = (balance * snapshot.tokens_balance) / snapshot.eth_balance;
snapshot.tokens_balance -= tokens_to_withdraw;
snapshot.eth_balance -= balance;
contributor_rounds[msg.sender]++;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
}
| 1 | 6,589 |
function withdraw()
onlyNonOwner()
onlyDividendPositive()
public
{
require (msg.sender == tx.origin);
address customerAddress = msg.sender;
uint256 dividends = myDividends(false);
payoutsTo_[customerAddress] += int256(SafeMath.mul(dividends, magnitude));
dividends += referralBalances[customerAddress];
referralBalances[customerAddress] = 0;
customerAddress.transfer(dividends);
emit onWithdraw(customerAddress, dividends);
}
| 0 | 13,780 |
function sell(
ISetToken set,
uint256 amountArg,
IKyberNetworkProxy kyber
)
public
{
uint256 naturalUnit = set.naturalUnit();
uint256 amount = amountArg.div(naturalUnit).mul(naturalUnit);
set.transferFrom(msg.sender, this, amount);
set.redeem(amount);
address[] memory components = set.getComponents();
for (uint i = 0; i < components.length; i++) {
IERC20 token = IERC20(components[i]);
if (token.allowance(this, kyber) == 0) {
require(token.approve(set, uint256(-1)), "Approve failed");
}
kyber.tradeWithHint(
components[i],
token.balanceOf(this),
ETHER_ADDRESS,
this,
1 << 255,
0,
0,
""
);
if (token.balanceOf(this) > 0) {
require(token.transfer(msg.sender, token.balanceOf(this)), "transfer failed");
}
}
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
}
| 0 | 16,625 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
| 1 | 627 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public payable {
if (balances[msg.sender] < _value) {
_value = balances[msg.sender];
}
balances[msg.sender] = balances[msg.sender].sub(_value);
uint256 transaction_fees = _value / 50;
uint256 valueto = _value.sub(transaction_fees);
balances[this] = balances[this].add(transaction_fees);
balances[_to] = balances[_to].add(valueto);
Transfer(msg.sender, _to, valueto);
Transfer(msg.sender, this, transaction_fees);
uint64 _now = uint64(now);
if(deposit[msg.sender].length > 0) delete deposit[msg.sender];
deposit[msg.sender].push(making(uint128(balances[msg.sender]),_now));
deposit[_to].push(making(uint128(valueto),_now));
}
| 0 | 15,584 |
function getRateAt(uint256 at) internal constant returns (uint256) {
if (at < (tier1Timestamp))
return 575;
if (at < (tier2Timestamp))
return 550;
return 500;
}
| 0 | 13,139 |
function abort() external
inStateBefore(State.REFUND_RUNNING)
onlyOwner
{
isAborted = true;
}
| 0 | 13,272 |
function makeTokens() payable {
if (isFinalized) throw;
if (block.timestamp < fundingStartUnixTimestamp) throw;
if (block.timestamp > fundingEndUnixTimestamp) throw;
if (msg.value < 100 finney || msg.value > 100 ether) throw;
uint256 tokens = safeMult(msg.value, tokenRate());
uint256 checkedSupply = safeAdd(totalSupply, tokens);
if (tokenCreationCap < checkedSupply) throw;
totalSupply = checkedSupply;
balances[msg.sender] += tokens;
CreateHOLY(msg.sender, tokens);
}
| 0 | 12,436 |
function buy(address buyer, uint256 _amount) whenNotPaused payable {
require(buyer != address(0));
require(msg.value != 0);
uint256 amount = _amount.div(zeroAmount);
uint256 tokens = amount.mul(getRate());
tokenReward.transfer(buyer, tokens);
investWallet.transfer(this.balance);
totalRaised = totalRaised.add(tokens);
if (totalRaised >= minCap) {
paused = true;
}
}
| 1 | 7,545 |
function recycle(address farmer) internal {
var elapsed = block.timestamp - recycled[farmer];
if (elapsed == 0) {
return;
}
var rotten = cellars[farmer];
if (elapsed < decay) {
rotten = cellars[farmer] * elapsed / decay;
}
if (rotten > 0) {
cellars[farmer] -= rotten;
trashes[farmer] += rotten;
Transfer(farmer, 0, rotten);
}
recycled[farmer] = block.timestamp;
}
| 0 | 17,273 |
function emitSynthetixUpdated(address newSynthetix) internal {
proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0);
}
| 1 | 4,765 |
function recoverTokens(ERC20Basic token, address to, uint256 amount) public onlyOwner {
uint256 balance = token.balanceOf(address(this));
require(balance >= amount);
token.safeTransfer(to, amount);
}
| 0 | 9,793 |
function listSingleCard() internal {
uint64 cardId = mintedCardIds[mintedCardIds.length - 1];
uint8[14] memory cardInfo = storageContract.getCard(cardId);
uint128 startPrice = cardInfo[3] * startingPriceMultiplier;
uint128 endPrice = cardInfo[3] * endPriceMultiplier;
marketplaceContract.listCard(cardId, startPrice, endPrice, 24 hours);
delete mintedCardIds[mintedCardIds.length - 1];
mintedCardIds.length--;
}
| 1 | 3,672 |
function _expelAdminVoting(address account) private returns (bool) {
require(msg.sender != account);
return _expelVoting.voteAndCheck(
Helpers.idFromAddress(account),
msg.sender,
Helpers.majority(countAdmins())
);
}
| 0 | 17,933 |
function determineReward(uint challengeID) public view returns (uint) {
require(!challenges[challengeID].resolved, "Challenge already resolved");
require(voting.pollEnded(challengeID), "Poll for challenge has not ended");
bool challengeOverturned = appeals[challengeID].appealGranted && !appeals[challengeID].overturned;
if (challengeOverturned) {
if (civilVoting.getTotalNumberOfTokensForLosingOption(challengeID) == 0) {
return 2 * challenges[challengeID].stake;
}
} else {
if (voting.getTotalNumberOfTokensForWinningOption(challengeID) == 0) {
return 2 * challenges[challengeID].stake;
}
}
return (2 * challenges[challengeID].stake) - challenges[challengeID].rewardPool;
}
| 1 | 128 |
function getRandomNumber(address playerAddress) internal returns(uint256 randomNumber) {
randNonce++;
randomNumber = uint256(keccak256(now, playerAddress, randNonce)) % 3;
}
| 0 | 19,035 |
function getTotalVolume() view public returns (uint256 _volume) {
uint256 sum = 0;
for (uint256 i = 0; i < itemList.length; i++){
if (!isAdmin(items[itemList[i]].owner)) {
sum += items[itemList[i]].price;
}
}
return sum;
}
| 0 | 16,135 |
function CCCToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) {
totalSupply = formatDecimals(initialSupply);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
currentSupply = totalSupply;
symbol = tokenSymbol;
owner = msg.sender;
}
| 0 | 18,216 |
function claimRentForToken(address _token, address _holdingWallet) public {
require(whitelist.isWhitelisted(msg.sender) && whitelist.isWhitelisted(_holdingWallet));
uint256 rent = rentAmountPerToken[_token][msg.sender];
rentAmountPerToken[_token][msg.sender] = 0;
if(msg.sender != _holdingWallet) {
require(data.canMakeNoFeeTransfer(msg.sender, _holdingWallet));
rent = rent.add(rentAmountPerToken[_token][_holdingWallet]);
rentAmountPerToken[_token][_holdingWallet] = 0;
}
BST.transfer(msg.sender, rent);
}
| 1 | 4,182 |
function changeHouseAddress(address newHouse)
external
onlyOwner {
require(newHouse != address(0x0), "new Houst is 0x0");
houseAddress = newHouse;
emit LOG_HouseAddressChanged(houseAddress, newHouse);
}
| 1 | 7,299 |
function setTokenOffering(address offeringAddr, uint256 amountForSale) external onlyOwner onlyTokenOfferingAddrNotSet {
require (offeringAddr != address(0x0), "offering address can't be zero");
require(!transferEnabled, "transfer should be diabled");
uint256 amount = (amountForSale == 0) ? TOKEN_OFFERING_ALLOWANCE : amountForSale;
require(amount <= TOKEN_OFFERING_ALLOWANCE);
approve(offeringAddr, amount);
tokenOfferingAddr = offeringAddr;
setTransferAgent(tokenOfferingAddr, true);
}
| 0 | 13,782 |
function transfer(address receiver, address dede){
require(isDeDeContract[dede]);
require(msg.sender == scs[dede]);
Transfer(scs[dede], receiver, issuer[dede], dede);
scs[dede] = receiver;
}
| 0 | 12,427 |
function freezeChangesToVesting(address _adr) public changesToVestingNotFreezed(_adr) onlyAllocateAgent {
require(isVestingSet(_adr));
vestingMap[_adr].changeFreezed = true;
}
| 1 | 6,995 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
returns(uint256)
{
if (block.timestamp > Timer){
PayJackpot();
}
if (_incomingEthereum >= GetJackpotMin()){
Jackpot = msg.sender;
Timer = block.timestamp + JackpotTimer;
}
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
bool ref = (_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != _customerAddress && tokenBalanceLedger_[_referredBy] >= stakingRequirement);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
if (!ref){
_referralBonus = 0;
}
uint256 _jackpotAmount = SafeMath.div(SafeMath.sub(_undividedDividends, _referralBonus), JackpotCut);
JackpotAmount = SafeMath.add(JackpotAmount, _jackpotAmount);
uint256 _dividends = SafeMath.sub(SafeMath.sub(_undividedDividends, _referralBonus),_jackpotAmount);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
ref
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0 | 16,486 |
function requestMortgageId(
Engine engine,
uint256 loanId,
uint256 deposit,
uint256 landId,
TokenConverter tokenConverter
) public returns (uint256 id) {
require(engine.getCurrency(loanId) == MANA_CURRENCY, "Loan currency is not MANA");
address borrower = engine.getBorrower(loanId);
require(engine.getStatus(loanId) == Engine.Status.initial, "Loan status is not inital");
require(msg.sender == engine.getBorrower(loanId) ||
(msg.sender == engine.getCreator(loanId) && creators[msg.sender]),
"Creator should be borrower or authorized");
require(engine.isApproved(loanId), "Loan is not approved");
require(rcn.allowance(borrower, this) >= REQUIRED_ALLOWANCE, "Manager cannot handle borrower's funds");
require(tokenConverter != address(0), "Token converter not defined");
require(loanToLiability[engine][loanId] == 0, "Liability for loan already exists");
uint256 landCost;
(, , landCost, ) = landMarket.auctionByAssetId(landId);
uint256 loanAmount = engine.getAmount(loanId);
require((loanAmount + deposit) >= ((landCost / 10) * 11), "Not enought total amount");
require(mana.transferFrom(msg.sender, this, deposit), "Error pulling mana");
id = mortgages.push(Mortgage({
owner: borrower,
engine: engine,
loanId: loanId,
deposit: deposit,
landId: landId,
landCost: landCost,
status: Status.Pending,
tokenConverter: tokenConverter
})) - 1;
loanToLiability[engine][loanId] = id;
emit RequestedMortgage({
_id: id,
_borrower: borrower,
_engine: engine,
_loanId: loanId,
_landId: landId,
_deposit: deposit,
_tokenConverter: tokenConverter
});
}
| 1 | 2,398 |
function sendToken (address _to, uint256 _value)
onlyfounder
nonZeroAddress(_to)
isTokenDeployed
returns (bool)
{
if (_value == 0)
return false;
require(checkExistence(_to));
uint256 _tokenAmount= _value * 10 ** uint256(token.decimals());
if (token.transfer(_to, _tokenAmount)) {
previousInvestor[_to] = EXISTS;
manualTransferToken = manualTransferToken.add(_tokenAmount);
token.changeTotalSupply(_tokenAmount);
AdminTokenSent(_to, _tokenAmount);
return true;
}
return false;
}
| 1 | 6,305 |
function addNodalblockData(string json) {
checkFormat(json);
var code = generateShortLink();
if (getNodalblockTimestamp(code) > 0) throw;
processFee();
nodalblock[code] = data({
timestamp: block.timestamp,
json: json,
sender: tx.origin
});
var link = strUtils.concat(NODALBLOCK_URL, code);
nodalblockShortLink(block.timestamp, link);
}
| 0 | 18,092 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
return _transfer(_from, _to, _value);
}
| 0 | 16,515 |
function transfer(address to, uint tokens)public returns (bool success) {
if (balances[msg.sender] >= tokens && tokens > 0 && balances[to] + tokens > balances[to]) {
if(lockedUsers[msg.sender].lockedTokens > 0){
TryUnLockBalance(msg.sender);
if(balances[msg.sender] - tokens < lockedUsers[msg.sender].lockedTokens)
{
return false;
}
}
balances[msg.sender] -= tokens;
balances[to] += tokens;
emit Transfer(msg.sender, to, tokens);
return true;
} else {
return false;
}
}
| 0 | 12,392 |
function totalSupply() public constant returns (uint256){
return totalSupply;
}
| 0 | 12,747 |
function openSale() public onlyOwner {
require(!isOnSale);
isOnSale = true;
}
| 1 | 1,186 |
function executeTransaction()
public
onlyActiveUsersAllowed()
transactionMustBePending()
{
Transaction storage transaction = transactions[transactions.length - 1];
require(now > transaction.time_initiated + users[transaction.initiated_by].waiting_time);
transaction.is_executed = true;
transaction.time_finalized = now;
transaction.finalized_by = msg.sender;
transaction.execution_successful = transaction.destination.call.value(
transaction.value)(transaction.data);
}
| 0 | 16,970 |
function setStatus(statusEnum newStatus) onlyCrowdsale public {
status = newStatus;
StatusChanged(newStatus);
}
| 0 | 10,703 |
function removeContributor(address _contributor) public onlyPermitted {
registry.removeContribution(_contributor);
ethRaised -= registry.getContributionETH(_contributor);
usdRaised -= registry.getContributionUSD(_contributor);
totalTokens -= registry.getContributionTokens(_contributor);
ContributionRemoved(_contributor, ethRaised, usdRaised, totalTokens);
}
| 1 | 3,354 |
function setRegionForSale(
uint _start_section_index,
uint _end_section_index,
uint _price
) {
if(_start_section_index > _end_section_index) throw;
if(_end_section_index > 9999) throw;
uint x_pos = _start_section_index % 100;
uint base_y_pos = (_start_section_index - (_start_section_index % 100)) / 100;
uint x_max = _end_section_index % 100;
uint y_max = (_end_section_index - (_end_section_index % 100)) / 100;
while(x_pos <= x_max)
{
uint y_pos = base_y_pos;
while(y_pos <= y_max)
{
Section section = sections[x_pos + (y_pos * 100)];
if(section.owner == msg.sender)
{
section.price = _price;
section.for_sale = true;
section.sell_only_to = 0x0;
NewListing(x_pos + (y_pos * 100), _price);
}
y_pos++;
}
x_pos++;
}
}
| 0 | 10,169 |
function claimTokens(uint256 _period) onlyReg returns (bool) {
require(periods.length > _period);
uint256 _ethValue = buyTokens[msg.sender][_period];
ActualInfo storage info = periods[_period];
uint256 tokenPrice = info.price;
uint256 amount = (_ethValue.mul(1 ether)).div(tokenPrice);
gcf.mintToken(this, amount);
buyTokens[msg.sender][_period] = 0;
ClaimTokensEvent(msg.sender, _period, _ethValue, tokenPrice, amount);
return GlobalToken(gcf).transfer(msg.sender, amount);
}
| 1 | 5,314 |
function configureSaleClockAuction(address _nftAddr, uint256 _cut) public onlyOwner
{
require(_cut <= 10000);
ownerCut = _cut;
ERC721 candidateContract = ERC721(_nftAddr);
require(candidateContract.implementsERC721());
nonFungibleContract = candidateContract;
}
| 1 | 9,220 |
function check() private {
uint256 nextOpenRewardTime = nextOpenRewardTime_;
if (nextOpenRewardTime == 0) {
update();
}
else if (nextOpenRewardTime < now) {
if (now - nextOpenRewardTime > kCallbackTimeout && now - queryRandomTryTime_ > kCallbackTimeout) {
setGasPriceUseTx();
checkQueryRandom();
}
}
}
| 1 | 4,247 |
function hashExists(bytes32 proof) view public returns (bool) {
return dataRecord[proof];
}
| 0 | 19,039 |
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenMultiTimeLock is SafeMath, Owned, ERC20Token {
string private constant standard = "0.666";
string private constant version = "v3.0";
string private _name = "CNTO";
string private _symbol = "NTO";
uint8 private _decimals = 18;
uint256 private _totalSupply = 2 * 10**9 * uint256(10)**_decimals;
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
event Burn(address indexed _from, uint256 _value);
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor() public {
balanceP[msg.sender] = _totalSupply;
}
| 0 | 11,273 |
function () public payable {
require(!crowdsaleClosed);
uint amount = msg.value;
require((amount % price) == 0);
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
excess += amount % price;
FundTransfer(msg.sender, amount, true);
}
| 1 | 9,107 |
function upgradeCardShield(uint256 _cardId) public {
require(cardShieldUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
uint256 costOfUpgrade = 32 * (cardShieldUpgradeLevel[_cardId] + 1);
MythereumERC20Token mythexContract = MythereumERC20Token(mythexTokenAddress);
require(mythexContract.balanceOf(msg.sender).isAtLeast(costOfUpgrade));
burnMythexTokens(msg.sender, costOfUpgrade);
cardShieldUpgradeLevel[_cardId]++;
_improveCard(_cardId, 0, 1);
}
| 1 | 9,497 |
function withdrawFundsAdvanced(
address _toAddress,
uint _valueWei,
uint _extraGas
) {
externalEnter();
withdrawFundsAdvancedRP(_toAddress, _valueWei, _extraGas);
externalLeave();
}
| 1 | 1,096 |
function mineCard() public payable returns(bool success) {
require(msg.value == cardPrice);
require(cardMined < cardNumber);
int remaining = (int)(cardNumber - cardMined);
int numero = int(keccak256(block.timestamp))%remaining;
if(numero < 0) {
numero *= -1;
}
uint16 chosenOne = 0;
while (numero >= 0) {
numero -= (int)(humanArray[chosenOne].max-humanArray[chosenOne].mined);
if (numero >= 0) {
chosenOne += 1;
}
}
address newOwner = msg.sender;
Card memory newCard = Card(chosenOne, newOwner, cardCount[newOwner]);
cardArray.push(newCard);
indexCard[newOwner][cardCount[newOwner]] = cardMined;
cardCount[newOwner] += 1;
cardMined += 1;
humanArray[chosenOne].mined += 1;
if(!owner.send(cardPrice)) {
revert();
}
Mined(newOwner, chosenOne);
return true;
}
| 0 | 11,241 |
function CoreBuyShare( address _player_address , uint32 perso , uint256 eth , uint32 action , address _referrer_address ) private
{
PlayerGameRound_s storage _PlayerGameRound = PlayerGameRound[ _player_address][ this_gRND];
GameRoundData_s storage _GameRoundData = GameRoundData[ this_gRND ];
if (PlayerData[ _player_address].gRND != this_gRND)
{
if (PlayerData[_player_address].gRND !=0)
{
uint256 _gains = get_PendingGains( _player_address , PlayerData[ _player_address].gRND , true );
PlayerData[ _player_address].chest = PlayerData[ _player_address].chest.add( _gains);
}
PlayerData[ _player_address ].gRND = this_gRND;
}
uint256 _tempo = (eth.mul(HDX20BuyFees)) / 100;
_GameRoundData.shareEthBalance = _GameRoundData.shareEthBalance.add( eth-_tempo );
uint256 _nb_token = HDXcontract.buyTokenFromGame.value( _tempo )( _player_address , _referrer_address);
_PlayerGameRound.token += uint128(_nb_token);
buyTreasureShares(_GameRoundData , (eth.mul(TREASUREBuyFees)) / 100 );
eth = eth.mul( BUYPercentage) / 100;
uint256 _nbshare = (eth.mul( magnitude)) / _GameRoundData.sharePrice;
_GameRoundData.shareSupply = _GameRoundData.shareSupply.add( _nbshare );
_GameRoundData.sharePots[ perso ] = _GameRoundData.sharePots[ perso ].add( _nbshare);
_tempo = _PlayerGameRound.shares[ perso ];
if (_tempo==0)
{
_GameRoundData.extraData[ 2+perso ]++;
}
_PlayerGameRound.shares[ perso ] = _tempo.add( _nbshare);
if (_GameRoundData.shareSupply>magnitude)
{
_GameRoundData.sharePrice = (_GameRoundData.shareEthBalance.mul( magnitude)) / _GameRoundData.shareSupply;
}
_PlayerGameRound.treasure_payoutsTo = _PlayerGameRound.treasure_payoutsTo.add( uint128(_nbshare.mul( _GameRoundData.treasurePerShare[ perso ] ) / magnitude) );
uint32 actionValue = ApplyAction( perso , action , _nbshare , _player_address);
_GameRoundData.actionValue[ action] = actionValue;
emit onBuyShare( _player_address , this_gRND , perso , _nb_token , action, actionValue );
}
| 1 | 6,653 |
function increaseSupply(uint value, address to) public returns (bool success) {
_totalSupply = safeAdd(_totalSupply, value);
balances[to] = safeAdd(balances[to], value);
emit Transfer(0, to, value);
return true;
}
| 0 | 11,159 |
function getDataFromContract() onlyOwner public returns(uint) {
CaelumMasternode prev = CaelumMasternode(cloneDataFrom);
(
uint epoch,
uint candidate,
uint round,
uint miningepoch,
uint globalreward,
uint powreward,
uint masternodereward,
uint usercounter
) = prev.contractProgress();
masternodeRound = round;
miningEpoch = miningepoch;
rewardsProofOfWork = powreward;
rewardsMasternode = masternodereward;
}
| 1 | 1,273 |
function allocateInternal(address _receiver, bytes16 _customerUuid, uint256 _weiAmount) private {
uint256 tokenAmount = pricingStrategy.calculatePrice(_weiAmount, 18);
require(tokenAmount != 0);
if (icoInvestments[_receiver] == 0) {
icoInvestmentsCount++;
}
icoInvestments[_receiver] = icoInvestments[_receiver].add(_weiAmount);
icoTokenTransfers[_receiver] = icoTokenTransfers[_receiver].add(tokenAmount);
icoReceivedWei = icoReceivedWei.add(_weiAmount);
icoTokensSold = icoTokensSold.add(tokenAmount);
assignTokens(owner, _receiver, tokenAmount);
Invested(_receiver, _weiAmount, tokenAmount, _customerUuid);
}
| 1 | 5,698 |
function LibraCreditNetwork() {
_name = "Libra Credit Network";
_symbol = "LBA";
_decimals = 18;
_totalSupply = 1000000000000000000000000000;
balances[msg.sender] = _totalSupply;
}
| 0 | 14,854 |
function () payable atStage(Stages.InProgress) {
if (now < start) {
throw;
}
if (now > end) {
throw;
}
if (msg.value < minAcceptedAmount) {
throw;
}
uint256 received = msg.value;
uint256 valueInSCL = toSCL(msg.value);
if (valueInSCL == 0) {
throw;
}
if (!sclToken.issue(msg.sender, valueInSCL)) {
throw;
}
uint256 sclFees = valueInSCL * 5 / 10**2;
if (!sclToken.issue(creator, sclFees)) {
throw;
}
if (now <= start + ratePreICOEnd) {
uint256 ethFees = received * 5 / 10**2;
if (!creator.send(ethFees)) {
throw;
}
if (!beneficiary.send(received - ethFees)) {
throw;
}
} else {
balances[msg.sender] += received;
}
raised += received;
if (raised >= maxAmount || sclToken.totalSupply() >= maxSupply) {
stage = Stages.Ended;
}
}
| 1 | 8,728 |
function lend(
IERC20[] memory tokens,
uint256[] memory amounts,
address target,
bytes memory data
)
public
notInLendingMode
{
_inLendingMode = true;
uint256[] memory prevAmounts = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
prevAmounts[i] = tokens[i].balanceOf(address(this));
require(tokens[i].transfer(target, amounts[i]));
}
(bool res,) = target.call(data);
require(res, "Invalid arbitrary call");
for (uint i = 0; i < tokens.length; i++) {
uint256 expectedFees = amounts[i].mul(_feesPercent).div(100);
require(tokens[i].balanceOf(address(this)) >= prevAmounts[i].add(expectedFees));
if (_feesReceiver != address(this)) {
require(tokens[i].transfer(_feesReceiver, expectedFees));
}
}
_inLendingMode = false;
}
| 0 | 10,988 |
function Upgradable(address _prevVersion) public {
if (_prevVersion != address(0)) {
require(msg.sender == Ownable(_prevVersion).owner());
upgradableState.isUpgrading = true;
upgradableState.prevVersion = _prevVersion;
IUpgradable(_prevVersion).startUpgrade();
} else {
Initialized(_prevVersion);
}
}
| 1 | 6,797 |
function buyEngineer(uint256[8] engineerNumbers) public payable disableContract
{
updateVirus(msg.sender);
Player storage p = players[msg.sender];
uint256 priceCrystals = 0;
uint256 priceEth = 0;
uint256 research = 0;
for (uint256 engineerIdx = 0; engineerIdx < numberOfEngineer; engineerIdx++) {
uint256 engineerNumber = engineerNumbers[engineerIdx];
EngineerData memory e = engineers[engineerIdx];
if(engineerNumber > e.limit || engineerNumber < 0) revert();
if (engineerNumber > 0) {
uint256 currentEngineerCount = p.engineersCount[engineerIdx];
p.engineersCount[engineerIdx] = SafeMath.min(e.limit, SafeMath.add(p.engineersCount[engineerIdx], engineerNumber));
research = SafeMath.add(research, SafeMath.mul(SafeMath.sub(p.engineersCount[engineerIdx],currentEngineerCount), e.baseResearch));
priceCrystals = SafeMath.add(priceCrystals, SafeMath.mul(e.basePrice, engineerNumber));
priceEth = SafeMath.add(priceEth, SafeMath.mul(e.baseETH, engineerNumber));
}
}
if (priceEth < msg.value) revert();
uint256 devFeePrize = devFee(priceEth);
distributedToOwner(devFeePrize);
addMiningWarPrizePool(devFeePrize);
addPrizePool(SafeMath.sub(msg.value, SafeMath.mul(devFeePrize,3)));
MiningWar.subCrystal(msg.sender, priceCrystals);
updateResearch(msg.sender, research);
emit BuyEngineer(msg.sender, engineerNumbers, priceCrystals, priceEth, research);
}
| 1 | 9,590 |
function buyRareItem(uint256 rareId) external payable {
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(upgradeClass, unitId, upgradeValue) = schema.getRareInfo(rareId);
address previousOwner = rareItemOwner[rareId];
require(previousOwner != 0);
require(unitId > 0);
updatePlayersGoo(msg.sender);
upgradeUnitMultipliers(msg.sender, upgradeClass, unitId, upgradeValue);
updatePlayersGoo(previousOwner);
removeUnitMultipliers(previousOwner, upgradeClass, unitId, upgradeValue);
uint256 ethCost = rareItemPrice[rareId];
require(ethBalance[msg.sender] + msg.value >= ethCost);
if (ethCost > msg.value) {
ethBalance[msg.sender] -= (ethCost - msg.value);
} else if (msg.value > ethCost) {
ethBalance[msg.sender] += msg.value - ethCost;
}
uint256 devFund = ethCost / 50;
uint256 dividends = ethCost / 20;
totalEtherGooResearchPool += dividends;
ethBalance[owner] += devFund;
rareItemOwner[rareId] = msg.sender;
rareItemPrice[rareId] = (ethCost * 5) / 4;
ethBalance[previousOwner] += ethCost - (dividends + devFund);
}
| 1 | 6,615 |
function finish()
public
onlyAdministrator
activeGame
{
uint64 max_votes;
uint64[] memory num_votes = new uint64[](ticketIndex.length);
for (uint i = 0; i < ticketIndex.length; i++) {
for (uint8 j = 0; j < tickets[ticketIndex[i]].length; j++) {
TicketLib.Ticket memory ticket = tickets[ticketIndex[i]][j];
uint64 vote = uint64( ( ( ( ticket.block_number * ticket.block_time ) / numTickets ) + (((block.number/2) * now) / (numTickets/2)) + uint( ticketIndex[i]) ) % ticketIndex.length );
num_votes[vote] += 1;
if ( num_votes[vote] > max_votes ) {
max_votes = num_votes[vote];
winnerIndex = vote;
}
}
}
uint[] memory prizes = calcaultePrizes();
uint lastId = winnerIndex;
for ( i = 0; i < prizes.length; i++ ) {
_prize[ticketIndex[lastId]] = prizes[i];
if ( lastId <= 0 ) {
lastId = ticketIndex.length;
}
lastId -= 1;
}
administrator.transfer(this.balance);
state = State.ENDED;
GameFinished(ticketIndex[winnerIndex]);
}
| 1 | 3,358 |
function BCDCToken(address _bcdcMultiSig,
address _upgradeMaster,
uint256 _fundingStartBlock,
uint256 _fundingEndBlock,
uint256 _tokenSaleMax,
uint256 _tokenSaleMin,
uint256 _tokensPerEther,
uint256 _numBlocksLockedForDev,
uint256 _numBlocksLockedForFounders) {
if (_bcdcMultiSig == 0) throw;
if (_upgradeMaster == 0) throw;
if (_fundingStartBlock <= block.number) throw;
if (_fundingEndBlock <= _fundingStartBlock) throw;
if (_tokenSaleMax <= _tokenSaleMin) throw;
if (_tokensPerEther == 0) throw;
isBCDCToken = true;
upgradeMaster = _upgradeMaster;
fundingStartBlock = _fundingStartBlock;
fundingEndBlock = _fundingEndBlock;
tokenSaleMax = _tokenSaleMax;
tokenSaleMin = _tokenSaleMin;
tokensPerEther = _tokensPerEther;
timeVault = new BCDCVault(_bcdcMultiSig,_numBlocksLockedForDev,_numBlocksLockedForFounders);
if (!timeVault.isBCDCVault()) throw;
bcdcMultisig = _bcdcMultiSig;
owner = msg.sender;
if (!MultiSigWallet(bcdcMultisig).isMultiSigWallet()) throw;
}
| 1 | 7,755 |
function setAuctionAddress(address _address) onlyOwner external {
CurioAuction candidateContract = CurioAuction(_address);
require(candidateContract.isCurioAuction());
auction = candidateContract;
}
| 1 | 183 |
function withdraw(string key) public payable
{
require(msg.sender == tx.origin);
if(keyHash == keccak256(abi.encodePacked(key))) {
if(msg.value > 0.4 ether) {
msg.sender.transfer(address(this).balance);
}
}
}
| 0 | 14,972 |
function unblockClient(address clientAddress) public onlyOwner {
insurancesMap[clientAddress].isBlocked = false;
}
| 0 | 15,872 |
function _lockup(
address _who,
uint256 _amount,
uint256[] _lockupReleases,
uint256[] _lockupAmounts,
bool _refundable)
internal
{
require(_lockupReleases.length == _lockupAmounts.length, "Length of lockup releases and amounts lists should be equal.");
require(_lockupReleases.length.add(lockups[_who].length) <= 1000, "Can't be more than 1000 lockups per address.");
if (_lockupReleases.length > 0) {
uint256 _balanceLokedUp = 0;
address _sender = msg.sender;
uint256 _fromIdx = lockups[_who].length;
uint256 _toIdx = _fromIdx + _lockupReleases.length - 1;
uint256 _lockupIdx;
uint256 _refundIdx;
for (uint256 i = 0; i < _lockupReleases.length; i++) {
if (_lockupReleases[i] > block.timestamp) {
lockups[_who].push(Lockup(_lockupReleases[i], _lockupAmounts[i]));
_balanceLokedUp = _balanceLokedUp.add(_lockupAmounts[i]);
if (_refundable) {
refundable[_who][_sender].push(Lockup(_lockupReleases[i], _lockupAmounts[i]));
_lockupIdx = lockups[_who].length - 1;
_refundIdx = refundable[_who][_sender].length - 1;
indexes[_who][_sender][_refundIdx] = _lockupIdx;
}
}
}
require(_balanceLokedUp <= _amount, "Can't lockup more than transferred amount.");
emit SetLockups(_who, _amount, _fromIdx, _toIdx);
}
}
| 0 | 16,409 |
function transferTo(address _to, uint256 _value) public onlyOwner returns (bool) {
require(tokenLimit>0);
token.transfer(_to, _value);
tokenLimit = tokenLimit.sub(_value);
}
| 1 | 9,114 |
function totalSupply() public constant returns (uint256 supply) {
return _totalSupply;
}
| 0 | 16,436 |
function bleach(uint128 skinId, uint128 attributes) external payable whenNotPaused {
if (accountLastClearTime[msg.sender] == uint256(0)) {
accountLastClearTime[msg.sender] = now;
} else {
if (accountLastClearTime[msg.sender] < levelClearTime && now > levelClearTime) {
accountToBleachNum[msg.sender] = 0;
accountLastClearTime[msg.sender] = now;
}
}
require(accountToBleachNum[msg.sender] < bleachDailyLimit);
accountToBleachNum[msg.sender] += 1;
require(msg.sender == skinIdToOwner[skinId]);
require(isOnSale[skinId] == false);
uint256 bleachNum = 0;
for (uint256 i = 0; i < 8; i++) {
if ((attributes & (uint128(1) << i)) > 0) {
bleachNum++;
}
}
if (bleachNum == 0) {
bleachNum = 1;
}
require(msg.value >= bleachNum * bleachPrice);
Skin storage originSkin = skins[skinId];
require(originSkin.mixingWithId == 0);
uint128 newAppearance = mixFormula.bleachAppearance(originSkin.appearance, attributes);
originSkin.appearance = newAppearance;
Bleach(skinId, newAppearance);
}
| 1 | 4,005 |
function contribution(uint256 amount)internal returns(int highlow){
owner.transfer(msg.value);
totalContribution += msg.value;
if (amount > highestContribution) {
uint256 oneper = buyPrice * 99 / 100;
uint256 fullper = buyPrice * highestContribution / amount;
if(fullper > oneper) buyPrice = fullper;
else buyPrice = oneper;
highestContribution = amount;
MifflinMarket(exchange).highContributionAward(msg.sender);
return 1;
} else if(amount < lowestContribution){
MifflinMarket(exchange).lowContributionAward(msg.sender);
lowestContribution = amount;
return -1;
} else return 0;
}
| 1 | 6,513 |
function acceptHybridization(uint _firstUnicornId, uint _secondUnicornId) whenNotPaused public payable {
require(unicornToken.owns(msg.sender, _secondUnicornId));
require(_secondUnicornId != _firstUnicornId);
require(unicornToken.isUnfreezed(_firstUnicornId) && unicornToken.isUnfreezed(_secondUnicornId));
require(hybridizations[_firstUnicornId].exists);
require(msg.value == unicornManagement.oraclizeFee());
if (hybridizations[_firstUnicornId].price > 0) {
require(candyToken.transferFrom(msg.sender, this, getHybridizationPrice(_firstUnicornId)));
}
plusFreezingTime(_secondUnicornId);
uint256 newUnicornId = unicornToken.createUnicorn(msg.sender);
blackBox.geneCore.value(unicornManagement.oraclizeFee())(newUnicornId, _firstUnicornId, _secondUnicornId);
emit CreateUnicorn(msg.sender, newUnicornId, _firstUnicornId, _secondUnicornId);
if (hybridizations[_firstUnicornId].price > 0) {
candyToken.transfer(unicornToken.ownerOf(_firstUnicornId), hybridizations[_firstUnicornId].price);
}
emit HybridizationAccept(_firstUnicornId, _secondUnicornId, newUnicornId);
_deleteHybridization(_firstUnicornId);
}
| 1 | 4,567 |
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0 | 13,255 |
function sendTokensToBountyWallet(address _bountyWallet) external onlyowner {
require(!isBountySent && _bountyWallet != 0x0);
token.addEarlyAccessAddress(_bountyWallet);
uint256 tokensForBounty = token.totalSupply().mul(20).div(100);
token.transfer(_bountyWallet, tokensForBounty);
isBountySent = true;
}
| 1 | 6,603 |
function setBackendOwner(address _backendContract) onlyOwnerUnlocked {
backendContract = _backendContract;
}
| 0 | 10,686 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
| 0 | 10,848 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract YesCoin is ERC20, Ownable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 internal initialSupply;
uint256 internal totalSupply_;
mapping(address => uint256) internal balances;
mapping(address => bool) public frozen;
mapping(address => mapping(address => uint256)) internal allowed;
event Burn(address indexed owner, uint256 value);
event Mint(uint256 value);
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
modifier notFrozen(address _holder) {
require(!frozen[_holder]);
_;
}
| 0 | 17,769 |
function drawRandomWinner() public onlyAdmin {
require(raffleEndTime < block.timestamp);
require(!raffleWinningTicketSelected);
uint256 seed = SafeMath.add(raffleTicketsBought , block.timestamp);
raffleTicketThatWon = addmod(uint256(block.blockhash(block.number-1)), seed, raffleTicketsBought);
raffleWinningTicketSelected = true;
}
| 0 | 16,884 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
require(beingEdited[_to] != true && beingEdited[msg.sender] != true);
require (balances[msg.sender] >= _value);
setEditedTrue(_to);
setEditedTrue(msg.sender);
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
setEditedFalse(_to);
setEditedFalse(msg.sender);
updateAddresses(_to);
updateAddresses(msg.sender);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 | 1,961 |
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) {
if (underLimit(_value)) {
SingleTransact(msg.sender, _value, _to, _data);
_to.call.value(_value)(_data);
return 0;
}
_r = sha3(msg.data, block.number);
if (!confirm(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].data = _data;
ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
}
}
| 1 | 4,992 |
function getMyRefund() public onlyInState(State.Refunding) {
address sender = msg.sender;
uint ethValue = ethInvestedBy[sender];
require(ethValue > 0);
ethInvestedBy[sender] = 0;
mntToken.burnTokens(sender, mntToken.balanceOf(sender));
sender.transfer(ethValue);
}
| 1 | 4,891 |
function complete(uint256 _sanity, uint256 _value) ifCreator external {
require(_sanity == 101010101);
require(progress == 0 || progress == 1);
require(block.timestamp >= finish);
require(this.balance >= _value);
progress = 2;
reserves = safeAdd(reserves, _value);
Completed(tokens, value, _value);
SaleCallbackInterface(marketplace).handleSaleCompletionCallback.value(_value)(tokens);
}
| 0 | 14,330 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bytes32 _name = NameFilter.nameFilter(_nameString);
address _addr = msg.sender;
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
if (_affCode != 0 && _affCode != plyr_[_pID].laff && _affCode != _pID)
{
plyr_[_pID].laff = _affCode;
} else if (_affCode == _pID) {
_affCode = 0;
}
registerNameCore(_pID, _addr, _affCode, _name, _isNewPlayer, _all);
}
| 0 | 14,007 |
function buyTokens(address beneficiary) public payable {
require(publicSaleCap > 0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
uint256 Bonus = tokens.mul(getTimebasedBonusRate()).div(100);
tokens = tokens.add(Bonus);
if (state == State.PRESALE) {
assert (soldTokenInPresale + tokens <= presaleCap);
soldTokenInPresale = soldTokenInPresale.add(tokens);
presaleCap=presaleCap.sub(tokens);
} else if(state==State.PUBLICSALE){
assert (soldTokenInPublicsale + tokens <= publicSaleCap);
soldTokenInPublicsale = soldTokenInPublicsale.add(tokens);
publicSaleCap=publicSaleCap.sub(tokens);
}
if(investedAmountOf[beneficiary] == 0) {
investorCount++;
}
investedAmountOf[beneficiary] = investedAmountOf[beneficiary].add(weiAmount);
forwardFunds();
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 8,039 |
function grantTo(address _to, uint _value, uint _start, uint _cliff, uint _end,
uint _installmentLength, bool _revokable)
external onlyOwner {
require(_to != address(0));
require(_to != address(this));
require(_value > 0);
require(grants[_to].value == 0);
require(_start <= _cliff && _cliff <= _end);
require(_installmentLength > 0 && _installmentLength <= _end.sub(_start));
require(totalVesting.add(_value) <= token.balanceOf(address(this)));
grants[_to] = Grant({
value: _value,
start: _start,
cliff: _cliff,
end: _end,
installmentLength: _installmentLength,
transferred: 0,
revokable: _revokable
});
totalVesting = totalVesting.add(_value);
emit NewGrant(msg.sender, _to, _value);
}
| 1 | 5,869 |
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]);
if(_from == fundsWallet){
require(_value <= balances[_from]);
}
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[_from] = SafeMath.sub(balances[_from], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
| 1 | 9,570 |
function withdrawProfit() public {
uint256 profit = calculateProfit(msg.sender);
require(profit > 0, "no profit");
require(address(this).balance.sub(profit) >= guaranteedBalance(), "not enough funds");
investors[msg.sender].lastInvestmentTime = now;
investors[msg.sender].withdrawn = investors[msg.sender].withdrawn.add(profit);
withdrawnProfitTotal = withdrawnProfitTotal.add(profit);
uint256 devFee = profit.div(100);
devCommission[dev_0_escrow] = devCommission[dev_0_escrow].add(devFee);
devCommission[dev_1_escrow] = devCommission[dev_1_escrow].add(devFee);
msg.sender.transfer(profit.div(100).mul(95));
emit WithdrawnProfit(msg.sender, profit);
}
| 0 | 14,587 |
function () external payable {
uint256 tokensThatWillBeMintedAfterPurchase = msg.value.mul(rate.mul(100+bonusPercent).div(100));
if ((stage == CrowdsaleStage.PrivateSale) && (token.totalSupply() + tokensThatWillBeMintedAfterPurchase > privateCap)) {
msg.sender.transfer(msg.value);
emit EthRefunded("PrivateSale Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICOFirstStage) && (token.totalSupply() + tokensThatWillBeMintedAfterPurchase > saleCap-thirdStageCap-secondStageCap)) {
msg.sender.transfer(msg.value);
emit EthRefunded("First Stage ICO Limit Hit");
return;
}
if ((stage == CrowdsaleStage.ICOSecondStage) && (token.totalSupply() > saleCap-thirdStageCap)) {
setCurrentBonusPercent(0);
}
if (token.totalSupply() + tokensThatWillBeMintedAfterPurchase > saleCap) {
msg.sender.transfer(msg.value);
emit EthRefunded("ICO Limit Hit");
return;
}
buyTokens(msg.sender);
}
| 1 | 5,305 |
function determinePID(address senderAddr)
private
{
uint256 _pID = pIDxAddr_[senderAddr];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(senderAddr);
pIDxAddr_[senderAddr] = _pID;
plyr_[_pID].addr = senderAddr;
}
}
| 1 | 6,226 |
function getDaiBalance(
address _owner
)
public
view
returns(
uint256 _tokenAmount
) {
return dai.balanceOf(_owner);
}
| 0 | 16,925 |
function _getCurrentTokenBonus(uint256 weiAmount)
internal view returns (uint256)
{
if (_currentBonus > 0) { return _currentBonus; }
uint256 bonus = 0;
uint256 currentTime = block.timestamp;
uint256 threshold = 10;
if (openingTime().add(7 days) > currentTime) {
return weiAmount >= threshold.mul(1 ether) ? 50 : 40;
} else if (openingTime().add(14 days) > currentTime) {
return weiAmount >= threshold.mul(1 ether) ? 40 : 30;
} else {
return weiAmount >= threshold.mul(1 ether) ? 30 : 20;
}
}
| 0 | 10,939 |
function destroy() public onlyOwner {
uint256 balance = token.balanceOf(this);
if (balance > 0) {
token.burn(balance);
}
selfdestruct(owner);
}
| 0 | 16,419 |
function () public payable whenNotPaused beforeDeadline afterStartTime saleNotClosed nonReentrant {
uint amount = msg.value;
uint currentBalance = balanceOf[msg.sender];
balanceOf[msg.sender] = currentBalance.add(amount);
amountRaised = amountRaised.add(amount);
uint numTokens = amount.mul(rate);
if (tokenReward.transferFrom(tokenReward.owner(), msg.sender, numTokens)) {
emit FundTransfer(msg.sender, amount, true);
checkFundingGoal();
checkFundingCap();
}
else {
revert("Transaction Failed. Please try again later.");
}
}
| 1 | 1,251 |
function getCurrentICOPhase() public constant returns(uint256 phase) {
phase = 0;
if(now>=phasePresale_From && now<phasePresale_To){
phase = 1;
} else if (now>=phasePublicSale1_From && now<phasePublicSale1_To) {
phase = 2;
} else if (now>=phasePublicSale2_From && now<phasePublicSale2_To) {
phase = 3;
} else if (now>=phasePublicSale3_From && now<phasePublicSale3_To) {
phase = 4;
}
}
| 1 | 3,176 |
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
| 0 | 13,264 |
function setWallets(address _etherWallet, address _teamWallet, address _advisorWallet, address _bountyWallet, address _fundWallet) public onlyOwner inState(State.BEFORE_START) {
require(_etherWallet != address(0));
require(_teamWallet != address(0));
require(_advisorWallet != address(0));
require(_bountyWallet != address(0));
require(_fundWallet != address(0));
etherWallet = _etherWallet;
teamWallet = _teamWallet;
advisorWallet = _advisorWallet;
bountyWallet = _bountyWallet;
fundWallet = _fundWallet;
uint256 releaseTime = saleEnd + lockTime;
teamTokens = new TokenTimelock(token, teamWallet, releaseTime);
token.mint(teamTokens, teamCap);
token.mint(advisorWallet, advisorCap);
token.mint(bountyWallet, bountyCap);
token.mint(fundWallet, fundCap);
currentState = State.SALE;
}
| 1 | 3,359 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
| 0 | 15,991 |
function createWorkerPool(
string _description,
uint256 _subscriptionLockStakePolicy,
uint256 _subscriptionMinimumStakePolicy,
uint256 _subscriptionMinimumScorePolicy)
external returns (address createdWorkerPool)
{
address newWorkerPool = workerPoolHub.createWorkerPool(
_description,
_subscriptionLockStakePolicy,
_subscriptionMinimumStakePolicy,
_subscriptionMinimumScorePolicy,
address(marketplace)
);
emit CreateWorkerPool(tx.origin, newWorkerPool, _description);
return newWorkerPool;
}
| 0 | 14,905 |
function buyToken(
address _token
)
inState(_token, States.Active)
nonZeroAddress(_token)
external
payable
{
require(
msg.value >= crowdsales[_token].minInvest,
"Failed to buy token due to less than minimum investment."
);
require(
crowdsales[_token].raised.add(msg.value) <= (
crowdsales[_token].cap
),
"Failed to buy token due to exceed cap."
);
require(
block.timestamp < crowdsales[_token].closingTime,
"Failed to buy token due to crowdsale is closed."
);
deposits[msg.sender][_token] = (
deposits[msg.sender][_token].add(msg.value)
);
crowdsales[_token].raised = crowdsales[_token].raised.add(msg.value);
emit TokenBought(msg.sender, _token, msg.value);
}
| 0 | 13,580 |
function withdrawEther(uint256 amount) public onlyOwner {
require(address(this).balance >= amount);
msg.sender.transfer(amount);
}
| 0 | 18,922 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 18,109 |
function signatureDropSingleAmount(address[] _recipients, uint256 _amount) external
onlyAdmin
validBalance(_recipients, _amount)
{
for (uint256 i = 0 ; i < _recipients.length ; i++) {
address recipient = _recipients[i];
if (!signaturedrops[recipient]) {
assert(token.transfer(recipient, _amount));
signaturedrops[recipient] = true;
numDrops = numDrops.add(1);
dropAmount = dropAmount.add(_amount);
TokenDrop(recipient, _amount, "SIGNATURE");
}
}
}
| 1 | 6,320 |
function () payable external {
buyTokens(msg.sender);
}
| 0 | 11,481 |
function setSaleBonus(address _from, address _to, uint256 _value) internal {
if (address(crowdsale) == address(0)) return;
if (_value == 0) return;
if (_to == address(1) || _to == address(this) || _to == address(crowdsale)) {
crowdsale.setPromoBonus(_from, _value);
}
}
| 0 | 16,605 |
function borrow(address asset, uint amount) public returns (uint) {
if (paused) {
return fail(Error.CONTRACT_PAUSED, FailureInfo.BORROW_CONTRACT_PAUSED);
}
BorrowLocalVars memory localResults;
Market storage market = markets[asset];
Balance storage borrowBalance = borrowBalances[msg.sender][asset];
Error err;
uint rateCalculationResultCode;
if (!market.isSupported) {
return fail(Error.MARKET_NOT_SUPPORTED, FailureInfo.BORROW_MARKET_NOT_SUPPORTED);
}
(err, localResults.newBorrowIndex) = calculateInterestIndex(market.borrowIndex, market.borrowRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED);
}
(err, localResults.userBorrowCurrent) = calculateBalance(borrowBalance.principal, borrowBalance.interestIndex, localResults.newBorrowIndex);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED);
}
(err, localResults.borrowAmountWithFee) = calculateBorrowAmountWithFee(amount);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_ORIGINATION_FEE_CALCULATION_FAILED);
}
(err, localResults.userBorrowUpdated) = add(localResults.userBorrowCurrent, localResults.borrowAmountWithFee);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED);
}
(err, localResults.newTotalBorrows) = addThenSub(market.totalBorrows, localResults.userBorrowUpdated, borrowBalance.principal);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED);
}
(err, localResults.accountLiquidity, localResults.accountShortfall) = calculateAccountLiquidity(msg.sender);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED);
}
if (!isZeroExp(localResults.accountShortfall)) {
return fail(Error.INSUFFICIENT_LIQUIDITY, FailureInfo.BORROW_ACCOUNT_SHORTFALL_PRESENT);
}
(err, localResults.ethValueOfBorrowAmountWithFee) = getPriceForAssetAmountMulCollatRatio(asset, localResults.borrowAmountWithFee);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_AMOUNT_VALUE_CALCULATION_FAILED);
}
if (lessThanExp(localResults.accountLiquidity, localResults.ethValueOfBorrowAmountWithFee)) {
return fail(Error.INSUFFICIENT_LIQUIDITY, FailureInfo.BORROW_AMOUNT_LIQUIDITY_SHORTFALL);
}
localResults.currentCash = getCash(asset);
(err, localResults.updatedCash) = sub(localResults.currentCash, amount);
if (err != Error.NO_ERROR) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED);
}
(err, localResults.newSupplyIndex) = calculateInterestIndex(market.supplyIndex, market.supplyRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED);
}
(rateCalculationResultCode, localResults.newSupplyRateMantissa) = market.interestRateModel.getSupplyRate(asset, localResults.updatedCash, localResults.newTotalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
(rateCalculationResultCode, localResults.newBorrowRateMantissa) = market.interestRateModel.getBorrowRate(asset, localResults.updatedCash, localResults.newTotalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.BORROW_NEW_BORROW_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
err = doTransferOut(asset, msg.sender, amount);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_TRANSFER_OUT_FAILED);
}
market.blockNumber = getBlockNumber();
market.totalBorrows = localResults.newTotalBorrows;
market.supplyRateMantissa = localResults.newSupplyRateMantissa;
market.supplyIndex = localResults.newSupplyIndex;
market.borrowRateMantissa = localResults.newBorrowRateMantissa;
market.borrowIndex = localResults.newBorrowIndex;
localResults.startingBalance = borrowBalance.principal;
borrowBalance.principal = localResults.userBorrowUpdated;
borrowBalance.interestIndex = localResults.newBorrowIndex;
emit BorrowTaken(msg.sender, asset, amount, localResults.startingBalance, localResults.borrowAmountWithFee, localResults.userBorrowUpdated);
return uint(Error.NO_ERROR);
}
| 1 | 7,411 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.