func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function _stakeTokens(TKN _tkn) private {
require(gameActive);
require(_zthToken(msg.sender));
require(validTokenBet[_tkn.value]);
if (now > gameEnds) { _settleAndRestart(); }
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
uint rightNow = now;
uint timePurchased = tokenToTimer[_tkn.value];
uint newGameEnd = rightNow.add(timePurchased);
gameStarted = rightNow;
gameEnds = newGameEnd;
currentWinner = _customerAddress;
contractBalance = contractBalance.add(_wagered);
uint houseCut = _wagered.div(100);
uint toAdd = _wagered.sub(houseCut);
houseTake = houseTake.add(houseCut);
tokensInPlay = tokensInPlay.add(toAdd);
emit TokensWagered(_customerAddress, _wagered, newGameEnd);
}
| 1 | 203 |
function deploy() public onlyOwner {
token = new CovestingToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(5,300);
presale.setMultisigWallet(0x055fa3f2DAc0b9Db661A4745965DDD65490d56A8);
presale.setStart(1507208400);
presale.setPeriod(2);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(1,200);
mainsale.addStage(2,100);
mainsale.setMultisigWallet(0x4d9014eF9C3CE5790A326775Bd9F609969d1BF4f);
mainsale.setFoundersTokensWallet(0x59b398bBED1CC6c82b337B3Bd0ad7e4dCB7d4de3);
mainsale.setBountyTokensWallet(0x555635F2ea026ab65d7B44526539E0aB3874Ab24);
mainsale.setStart(1507467600);
mainsale.setPeriod(2);
mainsale.setLockPeriod(1);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensPercent(13);
mainsale.setBountyTokensPercent(5);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
}
| 1 | 6,483 |
function _externalSaleSha3(
Currency _currency,
bytes32 _txIdSha3,
address _buyer,
uint256 _amountWei,
uint256 _tokensE18
) internal {
require(_buyer > 0 && _amountWei > 0 && _tokensE18 > 0);
var txsByCur = externalTxs[uint8(_currency)];
require(txsByCur[_txIdSha3] == 0);
txsByCur[_txIdSha3] = _tokensE18;
uint stageIndex = currentStage();
Stage storage stage = stages[stageIndex];
token.mint(this, _tokensE18);
token.transfer(msg.sender, _tokensE18);
totalTokensMinted = totalTokensMinted.add(_tokensE18);
totalExternalSales++;
totalInvested = totalInvested.add(_amountWei);
stage.invested = stage.invested.add(_amountWei);
if (stage.invested >= stage.hardcap) {
stage.closed = now;
}
ExternalSale(_currency, _txIdSha3, _buyer, _amountWei, _tokensE18);
}
| 1 | 3,940 |
function transferManager() onlyOwner Initialize clientManagerInit
{
require(now > payday);
if(First_pay_clientmanager==false && nbMonthsPay < 6)
{
pecul.transfer(clientmanager,montly_pay);
payday = payday.add( 31 days);
nbMonthsPay=nbMonthsPay.add(1);
MonthlyPaySend(montly_pay,clientmanager);
}
if(First_pay_clientmanager==true)
{
pecul.transfer(clientmanager,first_pay);
payday = payday.add( 31 days);
First_pay_clientmanager=false;
FirstPaySend(first_pay,clientmanager);
}
}
| 1 | 9,555 |
function safeDeduct(uint _a, uint _b) pure public returns(uint) {
if (_a < _b) return 0;
return (_a - _b);
}
| 0 | 18,447 |
function buy (uint256 _auctionId, address _referral) payable public {
NFTToken CNDERC721 = NFTToken(ERC721Contract);
require(auctions[_auctionId].endTime > now);
require(CNDERC721.ownerOf(auctions[_auctionId].monsterId) != address(0));
require(ceil(msg.value) >= ceil(auctions[_auctionId].price + increaseRate));
require(CNDERC721.ownerOf(auctions[_auctionId].monsterId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = CNDERC721.ownerOf(auctions[_auctionId].monsterId);
address newOwner = msg.sender;
uint256 oldPrice = auctions[_auctionId].price;
uint256 price = ceil(msg.value);
setGenes(price,auctions[_auctionId].monsterId);
CNDERC721.transferAuction(oldOwner, newOwner, auctions[_auctionId].monsterId);
auctions[_auctionId].price = ceil(price);
auctions[_auctionId].bidder = msg.sender;
DTT DTTtoken = DTT(dragonTreasureToken);
if(masterToReferral[msg.sender] != address(0) && masterToReferral[msg.sender] != msg.sender){
DTTtoken.approve(masterToReferral[msg.sender], DTTtoken.allowance(this,masterToReferral[msg.sender]) + price / 1000000000 * 5);
}else if(_referral != address(0) && _referral != msg.sender){
masterToReferral[msg.sender] = _referral;
DTTtoken.approve(_referral, DTTtoken.allowance(this,_referral) + price / 1000000000 * 5);
}
DTTtoken.approve(msg.sender, DTTtoken.allowance(this,msg.sender) + price / 1000000000 * 5);
if(oldPrice > 0)
oldOwner.transfer(oldPrice);
Bought(auctions[_auctionId].monsterId, newOwner, price);
Sold(auctions[_auctionId].monsterId, oldOwner, price);
}
| 1 | 4,933 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require(
allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& _value > 0
);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0 | 11,126 |
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]);
uint previousBalances = balances[_from] + balances[_to];
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);
assert(balances[_from] + balances[_to] == previousBalances);
return true;
}
| 0 | 10,006 |
function getSpinsContainer(bytes32 myid)
constant
returns(address, uint) {
return (spins[myid].playerAddress, spins[myid].amountWagered);
}
| 1 | 7,647 |
function roundProfitByAddr(address _pAddr, uint256 _round) public view returns (uint256) {
return roundProfit(_pAddr, _round);
}
| 0 | 19,414 |
function spawnCard(uint _craftedFromLeft, uint _craftedFromRight) internal returns(uint) {
CardStructure storage leftCard = allCards[_craftedFromLeft];
CardStructure storage rightCard = allCards[_craftedFromRight];
_startCraftRecovery(rightCard);
_startCraftRecovery(leftCard);
uint16 parentGen = leftCard.generation;
if (rightCard.generation > leftCard.generation) {
parentGen = rightCard.generation;
}
parentGen += 1;
if (parentGen > 18) {
parentGen = 18;
}
uint16[16] memory runes;
uint16[16] memory powers;
(runes, powers) = crafting.craft(leftCard.runes, leftCard.powers, rightCard.runes, rightCard.powers);
address owner = indexToOwner[_craftedFromLeft];
return _createCard(runes, powers, _craftedFromLeft, _craftedFromRight, parentGen, owner);
}
| 1 | 1,230 |
function validateXConversion(
IERC20Token[] _path,
uint256 _amount,
uint256 _block,
uint8 _v,
bytes32 _r,
bytes32 _s
)
private
validConversionPath(_path)
{
IERC20Token fromToken = _path[0];
require(msg.value == 0 || (_amount == msg.value && etherTokens[fromToken]));
require(_path[_path.length - 1] == registry.addressOf(ContractIds.BNT_TOKEN));
if (msg.value > 0) {
IEtherToken(fromToken).deposit.value(msg.value)();
} else {
ensureTransferFrom(fromToken, msg.sender, this, _amount);
}
if (_v == 0x0 && _r == 0x0 && _s == 0x0) {
IBancorGasPriceLimit gasPriceLimit = IBancorGasPriceLimit(registry.addressOf(ContractIds.BANCOR_GAS_PRICE_LIMIT));
gasPriceLimit.validateGasPrice(tx.gasprice);
} else {
require(verifyTrustedSender(_path, _amount, _block, msg.sender, _v, _r, _s));
}
}
| 1 | 9,166 |
function _validateOrder(uint amount, uint expiration, bytes32 h, address maker, uint price, uint validUntil, uint size, uint strike) private {
require(strike % 1 ether == 0, precisionError);
require(amount % 1 finney == 0, precisionError);
require(price % 1 finney == 0, precisionError);
require(expiration % 86400 == 0, "Expiration");
require(cancelled[maker][h] == false, "Cancelled");
require(amount <= size.sub(filled[maker][h]), "Filled");
require(now < validUntil, "OrderExpired");
require(now < expiration, "Expired");
filled[maker][h] = filled[maker][h].add(amount);
emit TakeOrder(msg.sender, maker, amount, h);
}
| 1 | 3,046 |
function disableInitialStage() onlyAdmin() public {
onlyAmbassadors = false;
}
| 0 | 13,897 |
function createLockSlot(address _holder, uint256[] _tokens, uint256[] _periods) public onlyGovernanceContracts {
require(_holder != address(0), "LockStorage cannot be created for this address");
require (_tokens.length == _periods.length && _tokens.length > 0);
require(_combineArray(_periods) <= maximumDurationToFreeze, "Incorrect time, should be less 3 years");
require(_combineArray(_tokens) > 0, "Incorrect amount");
uint256 fullAmount = _combineArray(_tokens);
uint256 newId = totalSlot.length;
token_.approveForOtherContracts(msg.sender, this, fullAmount);
token_.transferFrom(msg.sender, this, fullAmount);
lockTokenStorage[_holder][newId] = _createLockSlot(_tokens, _periods);
totalSlot.push(_holder);
totalLockedTokens = totalLockedTokens.add(fullAmount);
if(lockSlotIdList[_holder].length == 0) {
holdersList.push(_holder);
}
lockSlotIdList[_holder].push(newId);
emit LockSlotCreated(_holder, newId, fullAmount);
}
| 1 | 7,957 |
function withdrawBaseETH() public auth {
sendETH(base, msg.sender, base.balanceETH);
}
| 0 | 11,142 |
function transferFrom(address _from, address _to, uint256 _value, address sender)
public
onlyFront
returns (bool)
{
require(_to != address(0), "tokens MUST NOT go to the zero address");
require(_value <= allowed[_from][sender], "transfer value MUST NOT exceed allowance");
ICapTables(capTables).transfer(index, _from, _to, _value);
allowed[_from][sender] = allowed[_from][sender].sub(_value);
return true;
}
| 1 | 2,915 |
function _removeFromToken(address _fromContract, uint256 _fromTokenId, address _to, uint256 _tokenId) internal {
require(_fromContract != address(0));
require(_to != address(0));
require(tokenIdToTokenOwner[_tokenId].tokenOwner == _fromContract);
uint256 parentTokenId = tokenIdToTokenOwner[_tokenId].parentTokenId;
require(parentTokenId != 0);
require(parentTokenId - 1 == _fromTokenId);
address rootOwner = address(rootOwnerOf(_tokenId));
address approvedAddress = rootOwnerAndTokenIdToApprovedAddress[rootOwner][_tokenId];
require(rootOwner == msg.sender || tokenOwnerToOperators[rootOwner][msg.sender] || approvedAddress == msg.sender);
if (approvedAddress != address(0)) {
delete rootOwnerAndTokenIdToApprovedAddress[rootOwner][_tokenId];
emit Approval(rootOwner, address(0), _tokenId);
}
tokenIdToTokenOwner[_tokenId].parentTokenId = 0;
_removeChild(_fromContract, _fromTokenId, _tokenId);
emit TransferFromParent(_fromContract, _fromTokenId, _tokenId);
}
| 0 | 18,587 |
function calculateTokensReceived(uint256 ethereumToSpend)
public
pure
returns(uint256)
{
require(ethereumToSpend >= tokenPrice);
uint256 dividends = SafeMath.div(SafeMath.mul(ethereumToSpend, dividendFee ), 100);
uint256 taxedEthereum = SafeMath.sub(ethereumToSpend, dividends);
uint256 amountOfTokens = ethereumToTokens_(taxedEthereum);
return amountOfTokens;
}
| 0 | 16,579 |
function _applyRefCredits(address _receiver, uint256 _numAppliedCredits) private {
_numRefCredits[_receiver] = _numRefCredits[_receiver].add(_numAppliedCredits);
uint256 _numCredits = this.numRefCredits(_receiver, true);
uint256 _numRewards = _numCredits / REF_CREDITS_PER_AXIE;
if (_numRewards > 0) {
_numDeductedRefCredits[_receiver] = _numDeductedRefCredits[_receiver]
.add(_numRewards.mul(REF_CREDITS_PER_AXIE));
_numRewardedAxies[_receiver] = _numRewardedAxies[_receiver].add(_numRewards);
_totalRewardedAxies = _totalRewardedAxies.add(_numRewards);
AxiesRewarded(_receiver, _numRewards);
}
}
| 1 | 4,251 |
function setupRace(uint delay, uint locking_duration) onlyOwner beforeBetting public payable returns(bool) {
if (oraclize_getPrice("URL")*3 + oraclize_getPrice("URL", horses.customGasLimit)*3 > address(this).balance) {
emit newOraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee");
return false;
} else {
chronus.starting_time = uint32(block.timestamp);
chronus.betting_open = true;
bytes32 temp_ID;
emit newOraclizeQuery("Oraclize query was sent, standing by for the answer..");
chronus.betting_duration = uint32(delay);
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.ETH;
coinIndex[horses.ETH].preOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.LTC;
coinIndex[horses.LTC].preOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.BTC;
coinIndex[horses.BTC].preOraclizeId = temp_ID;
delay = delay.add(locking_duration);
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.ETH;
coinIndex[horses.ETH].postOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.LTC;
coinIndex[horses.LTC].postOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.BTC;
coinIndex[horses.BTC].postOraclizeId = temp_ID;
chronus.race_duration = uint32(delay);
return true;
}
}
function reward() internal {
horses.BTC_delta = int32(coinIndex[horses.BTC].post - coinIndex[horses.BTC].pre)*100000/int32(coinIndex[horses.BTC].pre);
horses.ETH_delta = int32(coinIndex[horses.ETH].post - coinIndex[horses.ETH].pre)*100000/int32(coinIndex[horses.ETH].pre);
horses.LTC_delta = int32(coinIndex[horses.LTC].post - coinIndex[horses.LTC].pre)*100000/int32(coinIndex[horses.LTC].pre);
total_reward = (coinIndex[horses.BTC].total) + (coinIndex[horses.ETH].total) + (coinIndex[horses.LTC].total);
if (total_bettors <= 1) {
forceVoidRace();
} else {
uint house_fee = total_reward.mul(5).div(100);
require(house_fee < address(this).balance);
total_reward = total_reward.sub(house_fee);
bettingControllerInstance.depositHouseTakeout.value(house_fee)();
}
if (horses.BTC_delta > horses.ETH_delta) {
if (horses.BTC_delta > horses.LTC_delta) {
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.BTC].total;
}
else if(horses.LTC_delta > horses.BTC_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else {
winner_horse[horses.BTC] = true;
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.BTC].total + (coinIndex[horses.LTC].total);
}
} else if(horses.ETH_delta > horses.BTC_delta) {
if (horses.ETH_delta > horses.LTC_delta) {
winner_horse[horses.ETH] = true;
winnerPoolTotal = coinIndex[horses.ETH].total;
}
else if (horses.LTC_delta > horses.ETH_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else {
winner_horse[horses.ETH] = true;
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.LTC].total);
}
} else {
if (horses.LTC_delta > horses.ETH_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else if(horses.LTC_delta < horses.ETH_delta){
winner_horse[horses.ETH] = true;
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.BTC].total);
} else {
winner_horse[horses.LTC] = true;
winner_horse[horses.ETH] = true;
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.BTC].total) + (coinIndex[horses.LTC].total);
}
}
chronus.race_end = true;
}
function calculateReward(address candidate) internal afterRace constant returns(uint winner_reward) {
voter_info storage bettor = voterIndex[candidate];
if(chronus.voided_bet) {
winner_reward = bettor.total_bet;
} else {
uint winning_bet_total;
if(winner_horse[horses.BTC]) {
winning_bet_total += bettor.bets[horses.BTC];
} if(winner_horse[horses.ETH]) {
winning_bet_total += bettor.bets[horses.ETH];
} if(winner_horse[horses.LTC]) {
winning_bet_total += bettor.bets[horses.LTC];
}
winner_reward += (((total_reward.mul(10000000)).div(winnerPoolTotal)).mul(winning_bet_total)).div(10000000);
}
}
function checkReward() afterRace external constant returns (uint) {
require(!voterIndex[msg.sender].rewarded);
return calculateReward(msg.sender);
}
function claim_reward() afterRace external {
require(!voterIndex[msg.sender].rewarded);
uint transfer_amount = calculateReward(msg.sender);
require(address(this).balance >= transfer_amount);
voterIndex[msg.sender].rewarded = true;
msg.sender.transfer(transfer_amount);
emit Withdraw(msg.sender, transfer_amount);
}
function forceVoidRace() internal {
chronus.voided_bet=true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
}
function stringToUintNormalize(string s) internal pure returns (uint result) {
uint p =2;
bool precision=false;
bytes memory b = bytes(s);
uint i;
result = 0;
for (i = 0; i < b.length; i++) {
if (precision) {p = p-1;}
if (uint(b[i]) == 46){precision = true;}
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {result = result * 10 + (c - 48);}
if (precision && p == 0){return result;}
}
while (p!=0) {
result = result*10;
p=p-1;
}
}
function getCoinIndex(bytes32 index, address candidate) external constant returns (uint, uint, uint, bool, uint) {
return (coinIndex[index].total, coinIndex[index].pre, coinIndex[index].post, coinIndex[index].price_check, voterIndex[candidate].bets[index]);
}
function reward_total() external constant returns (uint) {
return ((coinIndex[horses.BTC].total) + (coinIndex[horses.ETH].total) + (coinIndex[horses.LTC].total));
}
function refund() external onlyOwner {
require(now > chronus.starting_time + chronus.race_duration);
require((chronus.betting_open && !chronus.race_start)
|| (chronus.race_start && !chronus.race_end));
chronus.voided_bet = true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
bettingControllerInstance.remoteBettingClose();
}
function recovery() external onlyOwner{
require((chronus.race_end && now > chronus.starting_time + chronus.race_duration + (30 days))
|| (chronus.voided_bet && now > chronus.voided_timestamp + (30 days)));
bettingControllerInstance.depositHouseTakeout.value(address(this).balance)();
}
}
| 1 | 6,111 |
function mint(address _to, uint256 _amount)
onlyAsset('FundingManager')
public
returns (bool)
{
return TokenEntity.mint(_to, _amount);
}
| 0 | 15,020 |
function Take_payout() public {
require(Account_timePayout[msg.sender] < now);
if(next_payout<now){
payout=this.balance;
next_payout=now + 90 days;
}
msg.sender.transfer(payout.mul(Account_balances[msg.sender]).div(totalSupply));
Account_timePayout[msg.sender]=next_payout;
}
| 0 | 15,325 |
function sendSHPCtoContributors(uint start, uint limit) public onlyMultiOwnersType(12) {
require(state == SaleState.END);
require(start >= 0 && limit > 0);
require(getCoinBalance() > 0);
for (uint i = start; i < limit; i++) {
uint uId = storageContract.getContributorIndexes(i);
if (uId > 0) {
address addr = storageContract.getContributorAddressById(uId);
uint coins = storageContract.getTotalCoin(addr);
if (!storageContract.checkReceivedCoins(addr) && storageContract.checkWalletExists(addr) && coins > 0 && ((storageContract.checkPreSaleReceivedBonus(addr) && block.timestamp >= unfreezeRefundPreSale) || (!storageContract.checkPreSaleReceivedBonus(addr) && block.timestamp >= unfreezeRefundAll))) {
if (coinContract.transfer(addr, coins)) {
storageContract.setReceivedCoin(uId);
emit SendSHPCtoContributor(addr);
}
}
}
}
}
| 0 | 15,718 |
function sell(uint256 _amountOfTokens) onlyTokenHolders cooledOff public {
address _customerAddress = msg.sender;
bot[_customerAddress].active = false;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _maintenance = SafeMath.div(SafeMath.mul(_undividedDividends, maintenanceFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _maintenance);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _undividedDividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
fundBankRoll(_maintenance);
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
brbReinvest(_customerAddress);
}
| 1 | 6,204 |
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
| 0 | 18,464 |
function delProposal(uint _propID) internal {
uint k = 0;
while (k < ActiveProposals.length){
if (ActiveProposals[k].propID == _propID) {
require(ActiveProposals[k].endTime < now);
ActiveProposals[k] = ActiveProposals[ActiveProposals.length-1];
ActiveProposals.length = ActiveProposals.length-1;
} else {
k++;
}
}
}
| 0 | 12,226 |
function markParticipantIdentifiend(address participant) public grantOwnerOrAdmin notEnded {
participants[participant].identified = true;
if (participants[participant].suspendedDirectWeiAmount > 0) {
processPayment(participant, participants[participant].suspendedDirectWeiAmount, "");
suspendedPayments = suspendedPayments.sub(participants[participant].suspendedDirectWeiAmount);
participants[participant].suspendedDirectWeiAmount = 0;
}
if (participants[participant].suspendedExternalWeiAmount > 0) {
bytes32[] storage checksums = participantSuspendedExternalPaymentChecksums[participant];
for (uint i = 0; i < checksums.length; i++) {
processPayment(participant, suspendedExternalPayments[checksums[i]], checksums[i]);
suspendedExternalPayments[checksums[i]] = 0;
}
participants[participant].suspendedExternalWeiAmount = 0;
participantSuspendedExternalPaymentChecksums[participant] = new bytes32[](0);
}
}
| 1 | 2,725 |
function sell(uint256 amount) public returns(bool success) {
require(actived == true);
address user = msg.sender;
require(!frozenAccount[user]);
require(amount > 0);
require(balances[user] >= amount);
uint moneys = (amount * sellper * 10 finney)/sellPrice;
require(address(this).balance > moneys);
user.transfer(moneys);
balances[user] = balances[user].sub(amount);
if(balances[user] < myeth[user]) {
myeth[user] = balances[user];
}
balances[this] = balances[this].add(amount);
sysusermoney = sysusermoney.add(amount);
hassellmoney = hassellmoney.add(amount);
hasselleth = hasselleth.add(moneys);
emit Transfer(user, this, amount);
return(true);
}
| 1 | 4,290 |
function transferTokenToBuyer(address beneficiary, uint weiAmount) internal {
if (investedAmountOf[beneficiary] == 0) {
investorCount++;
}
uint tokenAmount = pricingStrategy.calculateTokenAmount(weiAmount, weiRaised);
investedAmountOf[beneficiary] = investedAmountOf[beneficiary].add(weiAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
token.transferFrom(owner, beneficiary, tokenAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokenAmount);
}
| 1 | 4,334 |
function borrowerCancel() public onlyBorrower atState(States.WaitingForFunds) {
uint amount = token.balanceOf(address(this));
token.transfer(borrowerAddress, amount);
currentState = States.Cancelled;
}
| 0 | 16,191 |
function releasableBalanceOf(address _owner) public view returns (uint256) {
uint256 result = 0;
for (uint i = 0; i < vestingsOf[_owner].length; i++) {
result += TokenVesting(vestingsOf[_owner][i]).releasableAmount(this);
}
return result;
}
| 0 | 12,069 |
function executeSubscription(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
uint256 nonce,
bytes signature
)
public
returns (bool success)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
require(to != from, "Can not send to the from address");
require(signer == from, "Invalid Signature");
require(
block.timestamp >= nextValidTimestamp[subscriptionHash],
"Subscription is not ready"
);
require( requiredToAddress == address(0) || to == requiredToAddress );
require( requiredTokenAddress == address(0) || tokenAddress == requiredTokenAddress );
require( requiredTokenAmount == 0 || tokenAmount == requiredTokenAmount );
require( requiredPeriodSeconds == 0 || periodSeconds == requiredPeriodSeconds );
require( requiredGasPrice == 0 || gasPrice == requiredGasPrice );
nextValidTimestamp[subscriptionHash] = block.timestamp.add(periodSeconds);
if(nonce > extraNonce[from]){
extraNonce[from] = nonce;
}
uint256 startingBalance = ERC20(tokenAddress).balanceOf(to);
ERC20(tokenAddress).transferFrom(from,to,tokenAmount);
require(
(startingBalance+tokenAmount) == ERC20(tokenAddress).balanceOf(to),
"ERC20 Balance did not change correctly"
);
require(
checkSuccess(),
"Subscription::executeSubscription TransferFrom failed"
);
emit ExecuteSubscription(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
);
if (gasPrice > 0) {
ERC20(tokenAddress).transferFrom(from, msg.sender, gasPrice);
require(
checkSuccess(),
"Subscription::executeSubscription Failed to pay gas as from account"
);
}
return true;
}
| 0 | 18,995 |
function identity_storage()
internal
view
returns (DaoIdentityStorage _contract)
{
_contract = DaoIdentityStorage(get_contract(CONTRACT_STORAGE_DAO_IDENTITY));
}
| 1 | 383 |
function setGarbageToVolumeRecorder(ERC20 token) internal {
for (uint i = 0; i < SLIDING_WINDOW_SIZE; i++) {
tokenImbalanceData[token][i] = 0x1;
}
}
| 0 | 13,680 |
function canSubAllocation(address sender, uint256 sub_value) private constant returns (bool)
{
if (sub_value==0)
{
return false;
}
if (balances[sender] < sub_value)
{
return false;
}
uint256 alllock_sum = 0;
for (uint j=0; j<allocations[sender].length; j++)
{
if (allocations[sender][j].time >= block.timestamp)
{
alllock_sum = alllock_sum.add(allocations[sender][j].balance);
}
}
uint256 can_unlock = balances[sender].sub(alllock_sum);
return can_unlock >= sub_value;
}
| 0 | 15,071 |
function withdraw() public isActivated isHuman {
uint256 _now = now;
uint256 _eth;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _rID = rID_;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) {
Datasets.EventData memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0) {
plyr_[_pID].addr.transfer(_eth);
}
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit Events.onWithdrawAndDistribute(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0) {
plyr_[_pID].addr.transfer(_eth);
}
emit Events.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 7,485 |
function() payable public {
require(status == 0 && price > 0 && gameTime > block.timestamp);
uint256 amount = msg.value.div(price);
balances_[msg.sender] = balances_[msg.sender].add(amount);
totalSupply_ = totalSupply_.add(amount);
emit Transfer(address(this), msg.sender, amount);
emit Buy(address(this), msg.sender, amount, msg.value);
}
| 0 | 12,945 |
function finishGame(BetDirection direction) public {
address player = msg.sender;
require(player != address(0));
require(gamesInProgress[player].state != GameState.None && gamesInProgress[player].state != GameState.Finished);
if (!rollDie(player)) {
return;
}
Game storage game = gamesInProgress[player];
game.direction = direction;
game.state = GameState.WaitingForFinalCard;
gamesInProgress[player] = game;
}
| 1 | 4,886 |
function getBlockInfo(uint8, uint8) public returns (address, uint, uint) {}
| 1 | 857 |
function getTokens(address contributor) payable stopInEmergency validPurchase public {
uint256 amount;
uint256 oddEthers;
uint256 ethers;
uint256 _at;
uint8 _winNum;
_at = block.timestamp;
require(contributor != 0x0);
if (withinPeriod()) {
(amount, oddEthers) = calcAmountAt(msg.value, _at, token.totalSupply());
require(amount.add(token.totalSupply()) <= hardCapInTokens);
ethers = msg.value.sub(oddEthers);
token.mint(contributor, amount);
TokenPurchase(contributor, ethers, amount);
counter_in = counter_in.add(ethers);
crowdTokensTLP2 = crowdTokensTLP2.add(amount);
if (oddEthers > 0) {
require(oddEthers < msg.value);
contributor.transfer(oddEthers);
TransferOddEther(contributor, oddEthers);
}
wallet.transfer(ethers);
} else {
require(msg.value >= minETHin);
_winNum = stageName();
require(_winNum >= 0 && _winNum < 5);
Window storage w = ww[_winNum];
require(w.tokenPerWindow > 0);
w.totalEthInWindow = w.totalEthInWindow.add(msg.value);
ppls[w.totalTransCnt].addr = contributor;
ppls[w.totalTransCnt].amount = msg.value;
w.totalTransCnt++;
TokenPurchaseInWindow(contributor, msg.value, _winNum, w.totalTransCnt, w.totalEthInWindow);
}
}
| 1 | 370 |
function purchaseInternal(address _sender, uint256 _incomingEthereum, address _referredBy)
purchaseFilter(_sender, _incomingEthereum)
internal
returns(uint256)
{
uint256 purchaseAmount = _incomingEthereum;
uint256 excess = 0;
if (totalInputETH_ <= initialBuyLimitCap_) {
if (purchaseAmount > initialBuyLimitPerTx_) {
purchaseAmount = initialBuyLimitPerTx_;
excess = SafeMath.sub(_incomingEthereum, purchaseAmount);
}
totalInputETH_ = SafeMath.add(totalInputETH_, purchaseAmount);
}
if (excess > 0) {
_sender.transfer(excess);
}
uint256 tmpBalanceBefore = _P3D.myTokens();
_P3D.buy.value(purchaseAmount)(_referredBy);
uint256 purchasedP3D = SafeMath.sub(_P3D.myTokens(), tmpBalanceBefore);
return purchaseTokens(_sender, purchasedP3D, _referredBy);
}
| 1 | 6,539 |
function getUserExp(address addr) public view returns(uint256 exp){
return userExpPool[addr];
}
| 0 | 11,441 |
function getAllTransactionIdsByEntityId(address entId) public returns (uint[] transactionIds)
{
require(token.getTokenBalance(msg.sender)>=perTransactionRate);
require(freezedTokens[entId] == false);
token.mint(msg.sender, wallet, perTransactionRate);
MakeTokenCreditAndDebitEntry(msg.sender);
EmitTransactionIds(entityTransactionsIds[entId]);
return entityTransactionsIds[entId];
}
| 1 | 2,561 |
function sendReward(uint intelIndex, uint rewardAmount) public returns(bool success){
require(intelIndex > 0, "Intel's ID should be greater than 0.");
require(rewardAmount > 0, "Reward amount should be greater than 0.");
IntelState storage intel = intelDB[intelIndex];
require(intel.intelProvider != address(0x0), "Intel for the provided ID does not exist.");
require(msg.sender != intel.intelProvider, "msg.sender should not be the current Intel's provider.");
require(intel.rewardAfter > now, "Intel is expired");
require(!intel.rewarded, "Intel is already rewarded");
if(rewardAmount <= balances[msg.sender]) {
balances[msg.sender] = balances[msg.sender].sub(rewardAmount);
balances[address(this)] = balances[address(this)].add(rewardAmount);
} else {
token.transferFrom(msg.sender, address(this), rewardAmount);
balances[address(this)] = balances[address(this)].add(rewardAmount);
totalParetoBalance = totalParetoBalance.add(rewardAmount);
}
intel.balance = intel.balance.add(rewardAmount);
if(intel.contributions[msg.sender] == 0){
intel.contributionsList.push(msg.sender);
}
intel.contributions[msg.sender] = intel.contributions[msg.sender].add(rewardAmount);
emit Reward(msg.sender, intelIndex, rewardAmount);
return true;
}
| 1 | 3,801 |
function destroyHUF(address to, uint256 value) public onlyOwner {
require (
to != 0x0 && value > 0 && _totalSupply >= value
);
balances[to] = balances[to].sub(value);
}
| 0 | 10,832 |
function deploy() public onlyOwner {
owner = 0x379264aF7df7CF8141a23bC989aa44266DDD2c62;
token = new GENSharesToken();
presale = new Presale();
presale.setToken(token);
token.setSaleAgent(presale);
presale.setMinInvestedLimit(100000000000000000);
presale.setPrice(250000000000000000000);
presale.setBountyTokensPercent(4);
presale.setAdvisorsTokensPercent(2);
presale.setDevTokensPercent(10);
presale.setSoftcap(46000000000000000000);
presale.setHardcap(50000000000000000000000);
presale.addBonus(7,50);
presale.addBonus(7,40);
presale.addBonus(100,35);
presale.setStart(1511571600);
presale.setEnd(1514156400);
presale.setDevLimit(6000000000000000000);
presale.setWallet(0x4bB656423f5476FeC4AA729aB7B4EE0fc4d0B314);
presale.setBountyTokensWallet(0xcACBE5d8Fb017407907026804Fe8BE64B08511f4);
presale.setDevTokensWallet(0xa20C62282bEC52F9dA240dB8cFFc5B2fc8586652);
presale.setAdvisorsTokensWallet(0xD3D85a495c7E25eAd39793F959d04ACcDf87e01b);
presale.setDevWallet(0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770);
ico = new ICO();
ico.setToken(token);
presale.setNextSaleAgent(ico);
ico.setMinInvestedLimit(100000000000000000);
ico.setPrice(250000000000000000000);
ico.setBountyTokensPercent(4);
ico.setAdvisorsTokensPercent(2);
ico.setDevTokensPercent(10);
ico.setHardcap(206000000000000000000000);
ico.addBonus(7,25);
ico.addBonus(14,10);
ico.setStart(1514163600);
ico.setEnd(1517356800);
ico.setWallet(0x65954fb8f45b40c9A60dffF3c8f4F39839Bf3596);
ico.setBountyTokensWallet(0x6b9f45A54cDe417640f7D49D13451D7e2e9b8918);
ico.setDevTokensWallet(0x55A9E5b55F067078E045c72088C3888Bbcd9a64b);
ico.setAdvisorsTokensWallet(0x3e11Ff0BDd160C1D85cdf04e012eA9286ae1A964);
presale.lockChanges();
ico.lockChanges();
presale.transferOwnership(owner);
ico.transferOwnership(owner);
token.transferOwnership(owner);
}
| 1 | 5,455 |
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
| 0 | 15,746 |
function batchSend(address[] memory targets, uint[] memory values, bytes[] memory datas) public payable {
for (uint i = 0; i < targets.length; i++)
targets[i].call.value(values[i])(datas[i]);
}
| 0 | 12,682 |
function approveProxy(address _from, address _spender, uint256 _value,
uint8 _v,bytes32 _r, bytes32 _s) returns (bool success) {
uint256 nonce = nonces[_from];
bytes32 hash = sha3(_from,_spender,_value,nonce);
if(_from != ecrecover(hash,_v,_r,_s)) throw;
allowed[_from][_spender] = _value;
Approval(_from, _spender, _value);
nonces[_from] = nonce + 1;
return true;
}
| 0 | 10,539 |
function _deployProxy(bytes32 _contractName, address _implementationAddress, bytes _data) private {
require(contracts_[_contractName].proxy_ == address(0), "Only one proxy can exist per upgradeable contract.");
AraProxy proxy = new AraProxy(address(this), _implementationAddress);
require(address(proxy).call(abi.encodeWithSignature("init(bytes)", _data)), "Init failed.");
contracts_[_contractName].proxy_ = proxy;
emit ProxyDeployed(_contractName, proxy);
}
| 1 | 8,841 |
function doPayment(address _owner) internal {
require ((now >= startFundingTime) &&
(now <= endFundingTime) &&
(tokenContract.controller() != 0) &&
(msg.value != 0) );
uint256 tokensAmount = mul(msg.value, exchangeRate) / 100;
require( totalTokenCount + tokensAmount <= tokenCap );
totalCollected += msg.value;
require (vaultAddress.call.gas(28000).value(msg.value)());
require (tokenContract.generateTokens(_owner, tokensAmount));
totalTokenCount += tokensAmount;
return;
}
| 1 | 6,859 |
function join() external {
_newMember(msg.sender);
}
| 0 | 10,973 |
function transferFrom(address _from, address _to, uint256 _value) canTransfer canTransferadv public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
| 0 | 15,825 |
function _transfer(
address source,
address destination,
uint amount
)
internal
hasSufficientBalance(source, amount)
whenTransferable(destination)
hasUnlockedAmount(source, amount)
{
require(destination != address(this) && destination != 0x0);
if (amount > 0) {
balances[source] -= amount;
balances[destination] = balances[destination].add(amount);
}
emit Transfer(source, destination, amount);
}
| 0 | 10,625 |
function processVote(bool isYes) internal {
require(isVotingActive);
require(!votesByAddress[msg.sender]);
votersLength = votersLength.add(1);
uint256 voteWeight = tokenContract.balanceOf(msg.sender);
if (isYes) {
yesVoteSum = yesVoteSum.add(voteWeight);
} else {
noVoteSum = noVoteSum.add(voteWeight);
}
require(getTime().sub(tokenContract.lastMovement(msg.sender)) > 7 days);
uint256 quorumPercent = getQuorumPercent();
if (quorumPercent == 0) {
isVotingActive = false;
} else {
decide();
}
votesByAddress[msg.sender] = true;
}
| 1 | 954 |
function call
if (isContract(controller)) {
if (!TokenController(controller).onApprove(msg.sender, _spender, _amount))
throw;
}
| 1 | 7,404 |
function sendToMarket(uint16 auctionIndex) public onlyOperator
{
Auction storage auction = auctions[auctionIndex];
require(auction.highestBidder == address(0));
auction.timeEnd = 0;
coreContract.transferFrom(coreContract.ownerOf(auction.cutieId), this, auction.cutieId);
coreContract.createSaleAuction(auction.cutieId, auction.highestBid, auction.highestBid, 60*60*24*365);
}
| 0 | 15,399 |
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Free already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
| 1 | 5,944 |
function hasEnded() public constant returns (bool) {
if (currentTime() > endTimestamp)
return true;
if (tokenRaised >= tokensForSale)
return true;
return false;
}
| 0 | 13,370 |
function referralCodeOwners(bytes32 _code) public view returns (address owner) {
address refCodeOwner = refCodeOwners[_code];
if(refCodeOwner == address(0)) {
return oldContract.referralCodeOwners(_code);
} else {
return refCodeOwner;
}
}
| 1 | 615 |
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin);
}
| 0 | 11,783 |
function checkForReceivedTokens() public{
if (getTokenBalance() != internalBalance){
uint256 receivedFunds = getTokenBalance().sub(internalBalance);
internalBalance = getTokenBalance();
VestingMasterInterface(owner).addLockedAmount(receivedFunds);
emit TokensReceivedSinceLastCheck(receivedFunds);
}
}
| 1 | 2,575 |
function buy() public payable {
require(buyersBalances[msg.sender] == 0);
require(msg.value == buyPrice);
require(hasTokens(msg.sender));
buyersBalances[msg.sender] = safeAdd(buyersBalances[msg.sender], msg.value);
}
| 1 | 53 |
function importUser(address target) onlyManager public
{
require(!upgraded[target], "Account already been upgraded");
upgraded[target] = true;
Transferable oldContract = Transferable(prevVersion);
uint256 amount = oldContract.balanceOf(target);
mintToken(target, amount, "Upgrade from previous version");
}
| 1 | 6,410 |
function claimCoreTeamsTokens(address _to) onlyOwner{
require(crowdsaleState == state.crowdsaleEnded);
require(!ownerHasClaimedTokens);
uint devReward = maxTokenSupply - token.totalSupply();
if (!cofounditHasClaimedTokens) devReward -= cofounditReward;
token.mintTokens(_to, devReward);
ownerHasClaimedTokens = true;
}
| 1 | 3,340 |
function setupRace(uint delay, uint locking_duration, address raceAddress) public payable onlyOwner {
if (oraclize_getPrice("URL" , horses.customPreGasLimit)*3 + oraclize_getPrice("URL", horses.customPostGasLimit)*3 > address(this).balance) {
} else {
bytes32 temp_ID;
emit newOraclizeQuery();
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[raceAddress][temp_ID] = horses.ETH;
oraclizeInverseIndex[temp_ID] = raceAddress;
coinIndex[raceAddress][horses.ETH].preOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[raceAddress][temp_ID] = horses.LTC;
oraclizeInverseIndex[temp_ID] = raceAddress;
coinIndex[raceAddress][horses.LTC].preOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[raceAddress][temp_ID] = horses.BTC;
oraclizeInverseIndex[temp_ID] = raceAddress;
coinIndex[raceAddress][horses.BTC].preOraclizeId = temp_ID;
delay = add(delay,locking_duration);
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[raceAddress][temp_ID] = horses.ETH;
oraclizeInverseIndex[temp_ID] = raceAddress;
coinIndex[raceAddress][horses.ETH].postOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[raceAddress][temp_ID] = horses.LTC;
oraclizeInverseIndex[temp_ID] = raceAddress;
coinIndex[raceAddress][horses.LTC].postOraclizeId = temp_ID;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[raceAddress][temp_ID] = horses.BTC;
oraclizeInverseIndex[temp_ID] = raceAddress;
coinIndex[raceAddress][horses.BTC].postOraclizeId = temp_ID;
}
}
| 1 | 3,516 |
function refundGame(uint commit) external {
Game storage bet = bets[commit];
bet.finished = true;
uint amount = bet.amount;
require (amount != 0, "Game should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Game has not expired yet");
bet.amount = 0;
uint diceWinAmount;
uint inviteProfit;
(diceWinAmount,inviteProfit) = getDiceWinAmount(amount, bet.rollUnder, bet.inviter);
lockedInBets -= uint128(diceWinAmount);
sendFunds(bet.player, amount);
}
| 0 | 9,897 |
function changePriceFactor(uint a_, uint b_, uint c_) public onlyCLevel {
priceFactorA = a_;
priceFactorB = b_;
priceFactorC = c_;
}
| 0 | 18,568 |
function () payable external {
revert();
}
| 0 | 16,351 |
function getRightSymbolFromByte(byte input) private pure returns(string memory symbol) {
byte val = input & 0x0f;
if (val == 0x00) {
symbol = '0';
} else if (val == 0x01) {
symbol = '1';
} else if (val == 0x02) {
symbol = '2';
} else if (val == 0x03) {
symbol = '3';
} else if (val == 0x04) {
symbol = '4';
} else if (val == 0x05) {
symbol = '5';
} else if (val == 0x06) {
symbol = '6';
} else if (val == 0x07) {
symbol = '7';
} else if (val == 0x08) {
symbol = '8';
} else if (val == 0x09) {
symbol = '9';
} else if (val == 0x0a) {
symbol = 'a';
} else if (val == 0x0b) {
symbol = 'b';
} else if (val == 0x0c) {
symbol = 'c';
} else if (val == 0x0d) {
symbol = 'd';
} else if (val == 0x0e) {
symbol = 'e';
} else if (val == 0x0f) {
symbol = 'f';
}
}
| 0 | 15,564 |
function buyTokens(address receiver, uint128 customerId, uint256 tokenAmount) stopInEmergency internal returns(uint tokensBought) {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
return tokenAmount;
}
| 1 | 9,685 |
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) {
if (msg.value>0) throw;
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(hash,v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) throw;
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
| 1 | 5,876 |
function approve(address _spender, uint256 _value) returns (bool success) {
if(!transfersEnabled) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 11,748 |
function blockAccount(address whom) onlyCSorOwner {
authorised[whom] = false;
}
| 0 | 15,800 |
function _computeNextGen0Price() internal view returns (uint256) {
uint256 avePrice = saleAuction.averageGen0SalePrice();
require(avePrice == uint256(uint128(avePrice)));
uint256 nextPrice = avePrice + (avePrice / 2);
if (nextPrice < GEN0_STARTING_PRICE) {
nextPrice = GEN0_STARTING_PRICE;
}
return nextPrice;
}
| 1 | 8,995 |
function() external payable {
require(msg.sender != address(0));
if(msg.sender == owner) return;
require(!paused,"The contract is paused");
require(address(this).balance + msg.value > address(this).balance);
require(msg.value >= minPurchase, "Smaller than minimum amount");
if(now > deadline || AUPC.allowance(owner,address(this)) <=0){
paused = true;
emit shouldBurn(msg.sender, AUPC.allowance(owner,address(this)) );
if(msg.value < address(this).balance)
msg.sender.transfer(msg.value);
return;
}
receivedAmount += msg.value;
payedETH[msg.sender] += msg.value;
if(savedLevels[msg.sender].timeStamp >0
&& savedLevels[msg.sender].timeStamp + oneDayTime >now){
require(purchaseAUPC(msg.sender, msg.value,savedLevels[msg.sender].level));
return;
}
string memory queryStr = strConcating(levelWebsite,addressToString(msg.sender));
emit makeQuery(msg.sender,"Oraclize level query sent",queryStr);
bytes32 queryId=oraclize_query("URL", queryStr, 600000);
oraclizeCallbacks[queryId] = rewardNode(msg.sender,msg.value,0,address(0),0,queryType.checkLevels);
}
| 0 | 13,145 |
function init(bytes32 _key, address _resolver)
internal
returns (bool _success)
{
bool _is_locked = ContractResolver(_resolver).locked_forever();
if (_is_locked == false) {
CONTRACT_ADDRESS = address(this);
resolver = _resolver;
key = _key;
require(ContractResolver(resolver).init_register_contract(key, CONTRACT_ADDRESS));
_success = true;
} else {
_success = false;
}
}
| 1 | 1,812 |
function refund() {
if (!has_token_sale_time_ended()) throw;
if (is_min_goal_reached()) throw;
if (block.number > refund_window_end_block) throw;
var refund_amount = balances[msg.sender];
if (refund_amount == 0) throw;
balances[msg.sender] = 0;
if (!msg.sender.send(refund_amount)) {
if (!msg.sender.send(refund_amount)) throw;
}
}
| 0 | 17,571 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
contractBalance = safeSub(contractBalance, oraclize_getPrice("URL", 235000));
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
totalBets += 1;
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1 | 990 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_from != address(0));
require(_to != address(0));
require(_value > 0);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
require(!frozenAccountSend[_from]);
require(!isBlackListed[_from]);
if(checkIsKYC(_from, _to)){
uint256 fee = (((_value.mul(feeRate)).div(10000)).div(10**(decimals))).mul(10**(decimals));
if(isWhiteListed[_from] || isWhiteListed[_to]){
fee = 0;
}else if(fee != 0){
if (fee > maximumFee) {
fee = maximumFee;
} else if (fee < minimumFee){
fee = minimumFee;
}
}
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
uint256 sendAmount = _value.sub(fee);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(sendAmount);
if (fee > 0) {
balanceOf[feeWallet] = balanceOf[feeWallet].add(fee);
emit Transfer(_from, feeWallet, fee);
}
emit Transfer(_from, _to, sendAmount);
return true;
} else {
emit Error_No_Binding_Address(_from, _to);
return false;
}
}
| 0 | 19,124 |
modifier onlyOwnerOrigin {
require(tx.origin == owner);
_;
}
| 0 | 11,663 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return tokenContract.allowance(_owner, _spender);
}
| 0 | 16,586 |
function in the implementing class.
finalization();
Finalized();
}
function finalization() internal;
}
contract SwarmCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public baseTokensSold = 0;
uint256 constant TOKEN_DECIMALS = 10**18;
uint256 constant TOKEN_TARGET_SOLD = 33333333 * TOKEN_DECIMALS;
uint256 constant MAX_TOKEN_SALE_CAP = 33333333 * TOKEN_DECIMALS;
bool public initialized = false;
function SwarmCrowdsale (
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
address _token,
uint256 _baseTokensSold
)
FinalizableCrowdsale(_startTime, _endTime, _rate, _wallet, _token)
{
baseTokensSold = _baseTokensSold;
}
function presaleMint(address _to, uint256 _amt) onlyOwner {
require(!initialized);
token.mint(_to, _amt);
}
function multiPresaleMint(address[] _toArray, uint256[] _amtArray) onlyOwner {
require(!initialized);
require(_toArray.length > 0);
require(_toArray.length == _amtArray.length);
for (uint i = 0; i < _toArray.length; i++) {
token.mint(_toArray[i], _amtArray[i]);
}
| 0 | 11,705 |
function symbol()
public
constant
returns (string)
{
return SYMBOL;
}
| 0 | 18,158 |
function getBalance() view public returns (uint256) {
return this.balance;
}
| 0 | 18,002 |
function depositErc20(address _tokenAddress, uint _amount) external {
require(_tokenAddress != address(0x0), "Token Address shouldn't be 0x0.");
IERC20 token = IERC20(_tokenAddress);
require(
token.transferFrom(msg.sender, address(this), _amount),
"Transfer operation should be successful."
);
tokensBalance[_tokenAddress] = tokensBalance[_tokenAddress].add(_amount);
emit FundsOperation (
msg.sender,
address(this),
_tokenAddress,
_amount,
PaymentType.Erc20,
OperationType.Receive
);
}
| 1 | 8,411 |
function payToken(address _tokenAddress, address _sellerAddress, uint _orderId, uint _value) public returns (bool success){
require(_tokenAddress != address(0));
require(_sellerAddress != address(0));
require(_value > 0);
Token token = Token(_tokenAddress);
require(token.allowance(msg.sender, this) >= _value);
token.transferFrom(msg.sender, feeAccountToken, _value.mul(feePercent).div(100000000));
token.transferFrom(msg.sender, _sellerAddress, _value.sub(_value.mul(feePercent).div(100000000)));
payment[_sellerAddress][_orderId] = BuyInfo(msg.sender, _sellerAddress, _value, _tokenAddress);
success = true;
}
| 1 | 2,942 |
function lockUnsoldTokens(address _unsoldTokensWallet)
public
saleEnded
setupComplete
onlyOwner
{
Disbursement disbursement = new Disbursement(
_unsoldTokensWallet,
1*365*24*60*60,
block.timestamp
);
disbursement.setup(token);
uint amountToLock = token.balanceOf(this);
disbursements.push(disbursement);
token.transfer(disbursement, amountToLock);
LockedUnsoldTokens(amountToLock, disbursement);
}
| 1 | 9,480 |
function _bid(address _sender, uint256 _platVal, uint256 _tokenId) internal {
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(order.tmSell == 0);
address realOwner = tokenContract.ownerOf(_tokenId);
require(realOwner == order.seller);
require(realOwner != _sender);
uint256 price = (uint256(order.price)).mul(1000000000000000000);
require(price == _platVal);
require(bitGuildContract.transferFrom(_sender, address(this), _platVal));
order.tmSell = tmNow;
auctionSumPlat += order.price;
uint256 sellerProceeds = price.mul(9).div(10);
tokenContract.safeTransferByContract(_tokenId, _sender);
bitGuildContract.transfer(realOwner, sellerProceeds);
AuctionPlatSold(lastIndex, realOwner, _sender, _tokenId, price);
}
| 1 | 3,163 |
function travelTo(uint256 _narcoId, uint256 _exitId) public payable whenNotPaused{
require(narcoCore.ownerOf(_narcoId) == msg.sender);
require((msg.value >= travelPrice && _exitId < 7) || (msg.value >= airLiftPrice && _exitId==7));
uint256 narcoWeedTotal;
uint256 narcoCokeTotal;
uint16[6] memory narcoSkills;
uint8[4] memory narcoConsumables;
uint256[6] memory narcoCooldowns;
(
,
narcoWeedTotal,
narcoCokeTotal,
narcoSkills,
narcoConsumables,
,
,
,
narcoCooldowns,
,
) = narcoCore.getNarco(_narcoId);
require(now>narcoCooldowns[0] && narcoConsumables[0]>0);
uint8 sourceLocation = getNarcoLocation(_narcoId);
District storage sourceDistrict = districts[sourceLocation];
require(_exitId==7 || sourceDistrict.exits[_exitId] != 0);
uint256 localWeedTotal = districts[sourceLocation].weedAmountHere;
uint256 localCokeTotal = districts[sourceLocation].cokeAmountHere;
if (narcoWeedTotal < localWeedTotal) {
districts[sourceLocation].weedAmountHere -= narcoWeedTotal;
} else {
districts[sourceLocation].weedAmountHere = 1;
}
if (narcoCokeTotal < localCokeTotal) {
districts[sourceLocation].cokeAmountHere -= narcoCokeTotal;
} else {
districts[sourceLocation].cokeAmountHere = 1;
}
uint8 targetLocation = getNarcoHomeLocation(_narcoId);
if (_exitId<7){
targetLocation = uint8(sourceDistrict.exits[_exitId]);
}
narcoIndexToLocation[_narcoId] = targetLocation;
_distributeRevenue(travelPrice, targetLocation , 50, 50);
districts[targetLocation].weedAmountHere += narcoWeedTotal;
districts[targetLocation].cokeAmountHere += narcoCokeTotal;
narcoCore.updateConsumable(_narcoId, 0 , narcoConsumables[0]-1);
narcoCore.setCooldown( _narcoId , 0 , now + (455-(5*narcoSkills[0])* 1 seconds));
narcoCore.incrementStat(_narcoId, 7);
uint64 bustChance=random(50+(5*narcoSkills[0]));
if (bustChance<=bustRange){
busted(_narcoId,targetLocation,narcoWeedTotal,narcoCokeTotal);
}
NarcoArrived(targetLocation, _narcoId);
NarcoLeft(sourceLocation, _narcoId);
}
| 1 | 4,678 |
function update() payable {
if (oraclize.getPrice("URL") > this.balance) {
newOraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee");
} else {
newOraclizeQuery("Oraclize query was sent, standing by for the answer..");
oraclize_query(60, "URL", "json(https:
}
}
| 1 | 2,618 |
function transferERC20(address _to, uint _value, address _token) external onlyowner returns (bytes32 _r) {
if (underLimit(_value)) {
emit SingleTransact(msg.sender, _value, _to);
ERC20Basic token = ERC20Basic(_token);
token.transfer(_to, _value);
return 0;
}
_r = keccak256(abi.encodePacked(msg.data, block.number));
if (!confirmERC20(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].token = _token;
emit ConfirmationERC20Needed(_r, msg.sender, _value, _to, token);
}
}
| 1 | 3,612 |
function finaliseExpiredProposal(uint256 _proposalId) internal {
ResultRecord storage result = ResultsByProposalId[_proposalId];
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(result.yes == 0 && result.no == 0) {
proposal.state = getRecordState("VOTING_RESULT_YES");
} else {
if(result.yes > result.no) {
proposal.state = getRecordState("VOTING_RESULT_YES");
} else if (result.no >= result.yes) {
proposal.state = getRecordState("VOTING_RESULT_NO");
}
}
runActionAfterResult(_proposalId);
}
| 1 | 8,235 |
function onERC721Received(
address _from,
uint256 _tokenId,
bytes
) public returns (bytes4) {
require(msg.sender == TVKeyAddress);
(, uint chestId) = ITVKey(TVKeyAddress).keys(_tokenId);
Chest memory chest = chests[chestId];
Lottery memory lottery = lotteries[chest.lotteryId];
ITVKey(TVKeyAddress).transferFrom(this, lottery.bank, _tokenId);
lotteries[chest.lotteryId].bankPercentage -= chest.percentage;
chests[chestId].openedCount = chest.openedCount + 1;
uint reward = getChestReward(chestId);
ITVToken(TVTokenAddress).transferFrom(lottery.bank, _from, reward);
emit ChestOpened(_tokenId, lottery.id, chest.id, reward, _from);
return ERC721_RECEIVED;
}
| 1 | 7,871 |
function transfer(address _to, uint256 _value) public{
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
| 0 | 17,459 |
function _transfer(address _from, address _to, uint _value) internal {
assert( lockedUntil[_from] == 0 || (lockedUntil[_from] != 0 && block.timestamp >= lockedUntil[_from]) );
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 0 | 19,334 |
function setTrainingFeeMultiplier(uint _newTrainingFeeMultiplier) external onlyOwner {
trainingFeeMultiplier = _newTrainingFeeMultiplier;
}
| 0 | 11,618 |
function receiveApproval(address _from, uint _amountOfTokens, address _token, bytes _data) external senderIsToken notPaused {
uint8 numberOfCoinSides = uint8(_data[31]);
uint8 playerChosenSide = uint8(_data[63]);
require((_amountOfTokens >= minAllowedBetInTokens) && (_amountOfTokens <= maxAllowedBetInTokens), "Invalid tokens amount.");
emit TokenStart(msg.sender, _from, _amountOfTokens);
uint tokensAmountAfterFees = _amountOfTokens.sub(tokenFee);
_checkGeneralRequirements(tokensAmountAfterFees, numberOfCoinSides, playerChosenSide);
require(token.transferFrom(_from, address(this), _amountOfTokens), "Tokens transfer failed.");
emit TokenTransferExecuted(_from, address(this), _amountOfTokens);
_initializeFlip(_from, BetCurrency.Token, tokensAmountAfterFees, 0, numberOfCoinSides, playerChosenSide, 0);
}
| 1 | 3,792 |
function _convertName(string _input) internal pure returns(bytes32 _initial, bytes32 _lowercase) {
bytes memory _initialBytes = bytes(_input);
assembly {
_initial := mload(add(_initialBytes, 32))
}
_lowercase = _toLowercase(_input);
}
| 0 | 11,763 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.