func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function contractFallback(address _receiver, uint256 _amount, bytes _data) private {
OwnersReceiver receiver = OwnersReceiver(_receiver);
receiver.onOwnershipTransfer(msg.sender, _amount, _data);
}
| 0 | 11,515 |
function contribute() onlyWhenRunning onlyifWhiteListed public payable {
require(msg.value >= 1 ether);
uint256 tokenBought;
uint256 bonus;
totalRaised = totalRaised.add(msg.value);
tokenBought = msg.value.mul(RATE);
if (msg.value >= 5 ether && msg.value <= 9 ether) {
bonus = (tokenBought.mul(20)).div(100);
tokenBought = tokenBought.add(bonus);
}
if (msg.value >= 10 ether) {
bonus = (tokenBought.mul(40)).div(100);
tokenBought = tokenBought.add(bonus);
}
require(BLU.balanceOf(this) >= tokenBought);
totalDistributed = totalDistributed.add(tokenBought);
BLU.transfer(msg.sender,tokenBought);
owner.transfer(msg.value);
emit LogContributorsPayout(msg.sender,tokenBought);
emit LogBeneficiaryPaid(owner);
emit LogFundingReceived(msg.sender, msg.value, totalRaised);
}
| 1 | 8,547 |
function finishDeal(uint _dealNumber) public{
uint deal = dealNumbers[_dealNumber];
require(deals[deal].balance > 0 && deals[deal].status == statuses.signed );
if(msg.sender == deals[deal].buyer){
signs[deal].finishSignBuyer = msg.sender;
}
if(msg.sender == deals[deal].seller){
signs[deal].finishSignSeller = msg.sender;
}
if(msg.sender ==deals[deal].signer){
signs[deal].finishSignSigner = msg.sender;
}
uint signCount = 0;
if(deals[deal].buyer == signs[deal].finishSignBuyer){
signCount++;
}
if(deals[deal].seller == signs[deal].finishSignSeller){
signCount++;
}
if(deals[deal].signer == signs[deal].finishSignSigner){
signCount++;
}
if(signCount >= 2){
deals[deal].seller.transfer(deals[deal].sum - deals[deal].fee);
emit MoneyTransfer(this,deals[deal].seller,deals[deal].sum-deals[deal].fee);
agencyReceiver.transfer(deals[deal].fee);
emit MoneyTransfer(this,agencyReceiver,deals[deal].fee);
deals[deal].balance = 0;
deals[deal].status = statuses.finished;
deals[deal].atClosed = now;
}
}
| 0 | 14,823 |
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
if(!initiated) return State.Prepairing;
else if (block.timestamp < startTime) return State.PreFunding;
else if (block.timestamp <= endTime && tokenSold<tokenCap) return State.Funding;
else if (tokenSold>=tokenCap) return State.Success;
else if (weiRaised > 0 && block.timestamp >= endTime && tokenSold<tokenCap) return State.Refunding;
else return State.Failure;
}
| 0 | 16,363 |
function getBalance() public view returns (uint256) {
return address(this).balance;
}
| 0 | 14,609 |
function claim(address from, address to, uint256 amount) public onlyOwner{
require(depositsMap[from].exists);
uint256 commission = mp.calculatePlatformCommission(amount);
require(address(this).balance > amount.add(commission));
require(depositsMap[from].balance >= amount);
mp.payPlatformOutgoingTransactionCommission.value(commission)();
emit PlatformOutgoingTransactionCommission(commission);
depositsMap[from].balance -= amount;
to.transfer(amount);
}
| 1 | 9,388 |
function ChinaInvestmentExchangeToken(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
| 0 | 10,070 |
function enter() {
if (msg.value < 80/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 40 ether) {
msg.sender.send(msg.value - 40 ether);
amount = 40 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += 0;
owner.send(collectedFees);
collectedFees = 0;
balance += amount;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 180) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 180;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 10,860 |
function getRandomNumber(uint _round) public payable returns (uint256){
uint256 tokenBalance = luckyYouToken.balanceOf(msg.sender);
if (tokenBalance >= 100000 * 10 ** 18)
{
return _getRandomNumber(_round);
} else if (msg.value >= basePrice) {
randomNumberIncome += msg.value;
return _getRandomNumber(_round);
} else {
revert();
return 0;
}
}
| 1 | 2,005 |
function tokensPerETH() view public returns(uint256)
{
uint256 EthPerToken = priceInETH();
return denominator * denominator / EthPerToken;
}
| 0 | 15,887 |
function withdraw() external onlyOwner {
address myAddress = address(this);
owner.transfer(myAddress.balance);
emit Ewithdraw(myAddress.balance);
}
| 0 | 15,233 |
function () onlyDuringICO payable {
totalContributions = safeAdd(totalContributions, msg.value);
contributions[msg.sender] = safeAdd(contributions[msg.sender], msg.value);
Contributed(msg.sender, msg.value, estimateBalanceOf(msg.sender));
}
| 0 | 13,411 |
function saveInitialParametersToStorage(uint256 _maxDelayDays, uint256 _tier, uint256 _communityMembers, address _community) external onlyOwnerOrLocalNode {
require(_maxDelayDays != 0);
require(state == LendingState.Uninitialized);
require(_tier > 0);
require(_communityMembers > 0);
require(ethicHubStorage.getBool(keccak256("user", "community", _community)));
ethicHubStorage.setUint(keccak256("lending.maxDelayDays", this), _maxDelayDays);
ethicHubStorage.setAddress(keccak256("lending.community", this), _community);
ethicHubStorage.setAddress(keccak256("lending.localNode", this), localNode);
ethicHubStorage.setUint(keccak256("lending.tier", this), _tier);
ethicHubStorage.setUint(keccak256("lending.communityMembers", this), _communityMembers);
tier = _tier;
state = LendingState.AcceptingContributions;
emit StateChange(uint(state));
}
| 1 | 2,257 |
function DistributedBank() public ParameterizedToken("Distributed Bank", "DBK", 18, 10000000000) {
}
| 0 | 17,901 |
function createNewElections() {
require(elections[nextElectionIndex - 1].endBlock + mandateInBlocks < block.number);
elections[nextElectionIndex].startBlock = block.number;
elections[nextElectionIndex].endBlock = block.number + blocksPerMonth;
elections[nextElectionIndex].totalCrbSupply = creditBitContract.totalSupply();
nextElectionIndex++;
creditCEO = 0x0;
}
| 1 | 5,574 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration * periods) || revoked[token]) {
return totalBalance;
} else {
uint256 periodTokens = totalBalance.div(periods);
uint256 periodsOver = now.sub(start).div(duration);
if (periodsOver >= periods) {
return totalBalance;
}
return periodTokens.mul(periodsOver);
}
}
| 1 | 9,083 |
function claim() payable {
if(block.number < 3910000) throw;
uint256 snt_per_eth = (block.number - 3910000) * 2;
uint256 snt_to_claim = snt_per_eth * msg.value;
uint256 contract_snt_balance = token.balanceOf(address(this));
if((contract_snt_balance - total_snt_claimed) < snt_to_claim) throw;
snt_claimed[msg.sender] += snt_to_claim;
total_snt_claimed += snt_to_claim;
developer.transfer(msg.value);
}
| 1 | 5,355 |
function internalContribution(address _contributor, uint256 _wei) internal {
require(getState() == State.InCrowdsale);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricingStrategy.getTokens(
_contributor, tokensAvailable, tokensSold, _wei, collectedWei);
require(tokens > 0 && tokens <= tokensAvailable);
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
if (msg.value > 0) {
contributionForwarder.forward.value(msg.value)();
}
emit Contribution(_contributor, _wei, tokensExcludingBonus, bonus);
}
| 1 | 6,093 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, 2, _eventData_);
}
| 1 | 7,935 |
function buy() whenNotPaused payable public{
require (msg.value >= ante + oracle_price);
require (player_count <2);
if(msg.value > (ante+oracle_price)) {
msg.sender.transfer(msg.value - ante - oracle_price);
}
player_count +=1;
if (player_count == 1) {
players.player1 = msg.sender;
}
if (player_count == 2) {
players.player2 = msg.sender;
ShowPlayers (players.player1,players.player2);
update();
player_count =0;
}
}
| 1 | 1,519 |
function createPeriodicAllocation(Token _token) external returns (PeriodicAllocation) {
PeriodicAllocation allocation = new PeriodicAllocation(_token);
allocation.transferOwnership(msg.sender);
return allocation;
}
| 1 | 1,378 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=currentReceiverIndex; i<queue.length; i++){
Deposit storage dep = queue[i];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[i];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex = i;
}
| 0 | 15,206 |
function setProvider(address newProvider) public onlyOwnerOrRequester returns (bool success) {
require(!providerLocked);
require(!requesterLocked);
provider = newProvider;
providerSet(provider);
return true;
}
| 0 | 13,200 |
function getCollectibleDetails(uint256 _tokenId)
external
view
returns (
uint256 isAttached,
uint32 sequenceId,
uint8 teamId,
uint8 positionId,
uint64 creationTime,
uint256 attributes,
uint256 playerOverrideId,
uint256 mlbGameId,
uint256 currentGameCardId,
uint256 mlbPlayerId,
uint256 earnedBy,
uint256 generationSeason
) {
NFT memory obj = _getAttributesOfToken(_tokenId);
attributes = obj.attributes;
currentGameCardId = obj.currentGameCardId;
mlbGameId = obj.mlbGameId;
playerOverrideId = obj.playerOverrideId;
mlbPlayerId = obj.mlbPlayerId;
creationTime = uint64(obj.assetDetails);
sequenceId = uint32(obj.assetDetails>>64);
teamId = uint8(obj.assetDetails>>96);
positionId = uint8(obj.assetDetails>>104);
isAttached = obj.isAttached;
earnedBy = obj.earnedBy;
generationSeason = generationSeasonDict[(obj.attributes % 1000000) / 1000];
}
| 0 | 17,701 |
function requestMortgageId(
Engine engine,
LandMarket landMarket,
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(engines[engine], "Engine not authorized");
require(engine.getStatus(loanId) == Engine.Status.initial, "Loan status is not inital");
require(
msg.sender == borrower || (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, "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,
landMarket: landMarket,
landId: landId,
landCost: landCost,
status: Status.Pending,
tokenConverter: tokenConverter
})) - 1;
loanToLiability[engine][loanId] = id;
emit RequestedMortgage({
_id: id,
_borrower: borrower,
_engine: engine,
_loanId: loanId,
_landMarket: landMarket,
_landId: landId,
_deposit: deposit,
_tokenConverter: tokenConverter
});
}
| 1 | 5,842 |
function buyTokens(address _addr) public payable {
require(msg.value >= 0.001 ether);
require(distributions[0] > 0);
require(totalBuyTokens_ <= INITIAL_SUPPLY );
require(getCurrentRound() > 0);
uint discountPercent = getCurrentDiscountPercent();
uint256 weiAmount = msg.value;
uint256 tokens = getRate(weiAmount);
uint256 bonusTokens = tokens.mul(discountPercent).div(100);
tokens += bonusTokens;
totalBuyTokens_ = totalBuyTokens_.add(tokens);
token.transfer(_addr, tokens);
totalSupply_ = totalSupply_.sub(tokens);
distributions[0] = distributions[0].sub(tokens);
owner.transfer(msg.value);
emit TokenPurchase(msg.sender, _addr, weiAmount, tokens);
}
| 1 | 7,122 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
checkNotLocked(msg.sender, _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 16,211 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1537164000 || msg.sender == deployer || msg.sender == multisend);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 12,820 |
function contribute() public notFinished payable {
uint256 tokenBought = 0;
totalRaised = totalRaised.add(msg.value);
totalContributors = totalContributors.add(1);
tokenBought = msg.value.mul(rate);
if (state == State.preico){
tokenBought = tokenBought.mul(14);
tokenBought = tokenBought.mul(10);
} else if (state == State.week1){
tokenBought = tokenBought.mul(13);
tokenBought = tokenBought.mul(10);
} else if (state == State.week2){
tokenBought = tokenBought.mul(125);
tokenBought = tokenBought.mul(100);
} else if (state == State.week3){
tokenBought = tokenBought.mul(12);
tokenBought = tokenBought.mul(10);
} else if (state == State.week4){
tokenBought = tokenBought.mul(115);
tokenBought = tokenBought.mul(100);
} else if (state == State.week5){
tokenBought = tokenBought.mul(11);
tokenBought = tokenBought.mul(10);
} else if (state == State.week6){
tokenBought = tokenBought.mul(105);
tokenBought = tokenBought.mul(100);
}
totalDistributed = totalDistributed.add(tokenBought);
require(creator.send(msg.value));
tokenReward.transfer(msg.sender, tokenBought);
LogFundingReceived(msg.sender, msg.value, totalRaised);
LogContributorsPayout(msg.sender, tokenBought);
checkIfFundingCompleteOrExpired();
}
| 1 | 5,832 |
function lock() onlyOwner returns (bool success) {
locked = true;
return true;
}
| 0 | 9,821 |
function getTokensLeft() view public returns(uint256) {
return hardCap.sub(tokensMinted);
}
| 0 | 12,718 |
function startpublicBattle(uint _pokemon1, uint _pokemon2) internal {
require(publicBattlepm1 != 99999 && publicBattlepm2 != 99999);
uint256 i = uint256(sha256(block.timestamp, block.number-i-1)) % 100 +1;
uint256 threshold = dataCalc(_pokemon1, _pokemon2);
if(i <= threshold){
pbWinner = publicBattlepm1;
}else{
pbWinner = publicBattlepm2;
}
battleresults.push(Battlelog(_pokemon1,_pokemon2,pbWinner));
distributePrizes();
}
| 1 | 522 |
function() payable public isRunning validAddress {
require(msg.value >= minEth);
require(now >= ico.icoStartDate && now <= ico.icoEndDate );
uint tokens = msg.value * tokenPerEth;
uint bonus = ( tokens.mul(ico.icoBonus) ).div(100);
uint total = tokens + bonus;
require(ico.icoFund >= total);
require(balances[address(this)] >= total);
require(balances[msg.sender].add(total) >= balances[msg.sender]);
ico.icoFund = ico.icoFund.sub(total);
ico.icoSold = ico.icoSold.add(total);
_sendTokens(address(this), msg.sender, total);
wallet.transfer( msg.value );
}
| 0 | 15,372 |
function approve(uint256 _id, bool _approve)
public
onlyAction
returns (bool success)
{
emit Approved(_id, _approve);
if (_approve == true) {
executions[_id].approved = true;
success = executions[_id].to.call(executions[_id].data, 0);
if (success) {
executions[_id].executed = true;
emit Executed(
_id,
executions[_id].to,
executions[_id].value,
executions[_id].data
);
} else {
emit ExecutionFailed(
_id,
executions[_id].to,
executions[_id].value,
executions[_id].data
);
}
return success;
} else {
executions[_id].approved = false;
}
return true;
}
| 1 | 234 |
function reclaimParsecCredit() external onlyOwner {
require(firstAuctionConcluded, "The first auction must have been concluded.");
_sendTo(owner, parsecCreditContract.balanceOf(this));
}
| 0 | 12,180 |
function withdraw() public onlyOwner {
token.safeTransfer(wallet, token.balanceOf(this));
emit Withdraw(wallet, token.balanceOf(this));
}
| 1 | 6,318 |
function hasEnded()
public
constant
returns(bool)
{
return now > publicEndTime;
}
| 0 | 11,992 |
function refund() restrictionOnUse isNotFrozen public {
require(this.balance < softcap);
uint value = ethBalance[msg.sender];
ethBalance[msg.sender] = 0;
msg.sender.transfer(value);
}
| 0 | 18,054 |
function doMelt(uint256 _xaurAmount, uint256 _goldAmount) public onlyOwner returns (bool) {
uint actualBalance = FreeXaurum();
uint totalSupply = XaurumInterface(XaurumAddress).totalSupply();
require(totalSupply >= _xaurAmount);
require(actualBalance >= _xaurAmount);
require(XaurumInterface(XaurumAddress).totalGoldSupply() >= _goldAmount);
XaurumInterface(XaurumAddress).doMelt(_xaurAmount, _goldAmount);
xaurumMelted += _xaurAmount;
goldMelted += _goldAmount;
xaurumDestroyed += _xaurAmount;
emit MeltDone(_xaurAmount, _goldAmount);
}
| 1 | 1,948 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(whitelist[beneficiary] == true);
require(validPurchase());
require(owner==pendingOwner);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
weiRaised = weiRaised.add(weiAmount);
numberOfPurchasers = numberOfPurchasers + 1;
forwardFunds();
}
| 1 | 6,361 |
function getSumInByLottery(uint32 idLottery) internal view returns (uint256)
{
Game storage curGame = game[idLottery];
uint256 sum = 0;
for(uint32 i=1;i<=curGame.countCombinations;i++) sum += betsAll[idLottery][i].sum;
return sum;
}
| 0 | 18,906 |
function icoEnd(bool) external onlyOwner{
icoStage = false;
}
| 0 | 18,029 |
function safeWithdrawal() public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
| 0 | 11,684 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
}
| 0 | 15,927 |
function AddBTCTransactionFromArray (address[] ETHadress, uint[] BTCnum, uint[] TransTime, bytes4[] bonusdata) public onlyOwner {
require(ETHadress.length == BTCnum.length);
require(TransTime.length == bonusdata.length);
require(ETHadress.length == bonusdata.length);
for (uint i = 0; i < ETHadress.length; i++) {
AddBTCTransaction(ETHadress[i], BTCnum[i], TransTime[i], bonusdata[i]);
}
}
| 0 | 18,593 |
function getActualPeriod() onlyOwner returns (uint256) {
uint256 period = fund.getActualPeriod();
return period.sub(1);
}
| 1 | 2,224 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Suohadatasets.EventReturns memory _eventData_)
private
returns(Suohadatasets.EventReturns)
{
uint256 _com = (_eth.mul(3)) / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit Suohaevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
}
| 0 | 18,547 |
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
require(_frozenTimes[from] == 0x0 || _frozenTimes[from] < now || isMinter(from));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| 0 | 15,246 |
function buyTokens(address _beneficiary) public payable whenNotPaused {
validatePurchase();
uint256 toFund = calculateToFund();
uint256 toReturn = msg.value.sub(toFund);
require(toFund > 0);
uint256 rate = getRate();
uint256 tokens = rate.mul(toFund);
require(tokens > 0);
if (block.timestamp < phase2StartTime) {
phase1WeiRaised = phase1WeiRaised.add(toFund);
} else {
phase2WeiRaised = phase2WeiRaised.add(toFund);
}
if (purchaserFunded[msg.sender] == 0) {
numPurchasers = numPurchasers.add(1);
}
purchaserFunded[msg.sender] = purchaserFunded[msg.sender].add(toFund);
token.generateTokens(_beneficiary, tokens);
emit TokenPurchase(msg.sender, _beneficiary, toFund, tokens);
if (toReturn > 0) {
msg.sender.transfer(toReturn);
}
vault.deposit.value(toFund)(msg.sender);
}
| 0 | 16,209 |
function token_transfer(address token, uint256 tokens)public payable
{
if(Token(token).approve(address(this),tokens))
{
dep_token[msg.sender][token] = safeAdd(dep_token[msg.sender][token], tokens);
Token(token).transferFrom(msg.sender,address(this), tokens);
}
}
| 1 | 5,571 |
function bet(uint256 _number,uint16 _use) safe() external{
require(_number >=12 && _number<=9876,'Please enter a correct number (2-4 digits)');
require(_use >=1 && _use<=1000,'Please enter a correct integer (1-1000)');
require(now<gameInfo_.nextLottery,'Please wait for the draw before you can continue to bet');
require(betSwitch==true,'Error Action');
uint256 pid=playAddr_[msg.sender];
require(pid>0);
player storage _p=player_[pid];
uint256 _index=gameInfo_.index;
playerRecord storage _pIndex=_p.index[_index];
require(_p.ticket>=_use,'No tickets available');
_p.ticket-=_use;
if(indexNumberTicket_[_index][_number]==0){
require(_pIndex.betNumbers <= gameConfig_.betMaxNumber,'Limited number of bet numbers');
_pIndex.betNumbers++;
}
_pIndex.betTickets +=_use;
indexNumberTicket_[_index][_number]+=_use;
_pIndex.numberOfTickets[_number] +=_use;
gameInfo_.lotteryResult[_index].betOfNumber+=_use;
gameInfo_.prizePool=add(gameInfo_.prizePool,mul(3000000000000000,_use));
emit Bet(msg.sender,_index,_number,_use);
}
| 1 | 4,523 |
constructor(
uint256 _fundingStartTime,
uint256 _fundingEndTime,
address _borrower,
uint256 _annualInterest,
uint256 _totalLendingAmount,
uint256 _lendingDays,
address _storageAddress,
address _localNode,
address _ethicHubTeam,
uint256 _ethichubFee,
uint256 _localNodeFee
)
EthicHubBase(_storageAddress)
public {
require(_fundingEndTime > fundingStartTime, "fundingEndTime should be later than fundingStartTime");
require(_borrower != address(0), "No borrower set");
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "representative", _borrower))), "Borrower not registered representative");
require(_localNode != address(0), "No Local Node set");
require(_ethicHubTeam != address(0), "No EthicHub Team set");
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "localNode", _localNode))), "Local Node is not registered");
require(_totalLendingAmount > 0, "_totalLendingAmount must be > 0");
require(_lendingDays > 0, "_lendingDays must be > 0");
require(_annualInterest > 0 && _annualInterest < 100, "_annualInterest must be between 0 and 100");
version = 7;
reclaimedContributions = 0;
reclaimedSurpluses = 0;
borrowerReturnDays = 0;
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
localNode = _localNode;
ethicHubTeam = _ethicHubTeam;
borrower = _borrower;
annualInterest = _annualInterest;
totalLendingAmount = _totalLendingAmount;
lendingDays = _lendingDays;
ethichubFee = _ethichubFee;
localNodeFee = _localNodeFee;
state = LendingState.Uninitialized;
}
| 1 | 5,793 |
function increaseApprovalPreSigned(
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _version,
bytes _sig
)
public
onlyNotFrozenAddress(msg.sender)
whenNotPaused
returns (bool)
{
require(_signatures[_sig] == false);
address _from = _preSignedContract.increaseApprovalPreSignedCheck(
address(this),
_to,
_value,
_fee,
_nonce,
_version,
_sig
);
require(!frozenAddress[_from]);
require(_fee <= balances[_from]);
allowed[_from][_to] = allowed[_from][_to].add(_value);
emit Approval(_from, _to, allowed[_from][_to]);
if (_fee > 0) {
balances[_from] = balances[_from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Transfer(_from, msg.sender, _fee);
}
_signatures[_sig] = true;
emit ApprovalPreSigned(_from, _to, msg.sender, allowed[_from][_to], _fee);
return true;
}
| 1 | 5,738 |
function game (uint level) payable returns (bytes32) {
if (msg.value <= 0) throw;
if (level > 10) throw;
if (level < 1) throw;
if (msg.value > 10 ether) throw;
uint random_number;
bytes32 myid = oraclize_query("WolframAlpha", "random integer number between 1 and 10");
bets[myid] = msg.sender;
betsvalue[myid] = msg.value;
betslevel[myid] = level;
LogB(myid);
return myid;
}
| 1 | 4,728 |
function airDrop(address parent, uint[] amounts, address[] droptargets) public payable {
if(msg.value > 0){
buyTokens();
}
require(balances[msg.sender] >= droptargets.length,"Insufficient funds to execute this airdrop");
ERC20TokenInterface parentContract = ERC20TokenInterface(parent);
uint allowance = parentContract.allowance(msg.sender, flairdrop);
uint amount = amounts[0];
uint x = 0;
address target;
while(gasleft() > 21000 && x <= droptargets.length - 1 ){
target = droptargets[x];
if(amounts.length == droptargets.length){
amount = amounts[x];
}
if(allowance >=amount){
parentContract.transferFrom(msg.sender,target,amount);
allowance -= amount;
}
x++;
}
balances[msg.sender] -= x;
totalSupply = totalSupply >= x ? totalSupply - x : 0;
emit Transfer(msg.sender, address(0), x);
emit AirDropEvent(parent,droptargets,amounts);
}
| 1 | 7,818 |
function revokeVesting(PeriodicTokenVesting _vesting, ERC20Basic token) public onlyOwner() {
_vesting.revoke(token);
emit VestingRevoked(_vesting);
}
| 1 | 8,859 |
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
| 0 | 19,376 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool) {
if(msg.sender == _to) return mint();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
| 0 | 15,275 |
function transferFrom(address _from, address _to, uint256 _tokenId) requireDataContract requireBattleContract requireTradeContract external {
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterObjAcc memory obj;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, obj.createIndex, obj.lastClaimIndex, obj.createTime) = data.getMonsterObj(uint64(_tokenId));
require(obj.monsterId == uint64(_tokenId));
require(obj.trainer == _from);
require(_to != address(0));
require(_to != _from);
require(allowed[_from][_tokenId] == msg.sender);
EtheremonBattle battle = EtheremonBattle(battleContract);
EtheremonTradeInterface trade = EtheremonTradeInterface(tradeContract);
if (battle.isOnBattle(obj.monsterId) || trade.isOnTrading(obj.monsterId))
revert();
allowed[_from][_tokenId] = address(0);
data.removeMonsterIdMapping(obj.trainer, obj.monsterId);
data.addMonsterIdMapping(_to, obj.monsterId);
Transfer(obj.trainer, _to, _tokenId);
}
| 1 | 2,437 |
function keys(uint256 _eth)
internal
view
returns(uint256)
{
if (linearPrice==0)
{return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);}
else
{return 1e18.mul(_eth) / linearPrice;}
}
| 0 | 14,087 |
function SenegalvsColombia() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 11,989 |
function _depositToken(address _to, uint256 _amount) internal {
require(_to != 0x0);
DonQuixoteToken.withhold(_to, _amount);
userTokenOf[_to] = userTokenOf[_to].add(_amount);
}
| 1 | 3,167 |
function tokenURI(
uint256 _tokenId
)
external
view
validNFToken(_tokenId)
returns (string memory)
{
return idToUri[_tokenId];
}
| 0 | 13,752 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Quantastic is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "Quantastic";
string public constant symbol = "QTIC";
uint public constant decimals = 8;
uint256 public totalSupply = 85000000e8;
uint256 public totalDistributed = 0;
uint256 public tokensPerEth = 100000e8;
uint256 public constant minContribution = 1 ether / 1000;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0 | 15,920 |
function withdrawImpl(
address receiver,
address onBehalfOf
)
private
returns (uint256)
{
uint256 value = balanceOf(onBehalfOf);
if (value == 0) {
return 0;
}
uint256 heldTokenBalance = TokenInteract.balanceOf(heldToken, address(this));
uint256 heldTokenPayout = MathHelpers.getPartialAmount(
value,
totalSupply_,
heldTokenBalance
);
delete balances[onBehalfOf];
totalSupply_ = totalSupply_.sub(value);
TokenInteract.transfer(heldToken, receiver, heldTokenPayout);
emit Withdraw(onBehalfOf, value, heldTokenPayout);
return heldTokenPayout;
}
| 0 | 14,027 |
function release(uint256 _id) adExists(_id) onlyAdOwner(_id) external {
uint16 tokens = ads[_id].rect.width.mul(ads[_id].rect.height);
for (uint16 i = 0; i < ads[_id].rect.width; i++) {
for (uint16 j = 0; j < ads[_id].rect.height; j++) {
uint16 x = ads[_id].rect.x.add(i);
uint16 y = ads[_id].rect.y.add(j);
grid[x][y] = false;
}
}
delete ads[_id];
uint256 key = adIdToIndex[_id];
adIds[key] = adIds[adIds.length - 1];
adIdToIndex[adIds[key]] = key;
adIds.length--;
if (now < allAdStart) {
presales[msg.sender] = presales[msg.sender].add(tokens);
}
token.unlockToken(msg.sender, tokens);
emit Release(_id, msg.sender);
}
| 1 | 7,016 |
function withdrawToken (address addressOfToken, uint256 amount) public onlyOwner returns (bool) {
bytes4 hashOfTransfer = bytes4(keccak256('transfer(address,uint256)'));
return addressOfToken.call(hashOfTransfer, owner, amount);
}
| 0 | 13,386 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
antiEarlyWhale(_incomingEthereum)
returns(uint256)
{
if (block.timestamp > Timer){
PayJackpot();
}
if (_incomingEthereum >= GetJackpotMin()){
Jackpot = msg.sender;
Timer = block.timestamp + JackpotTimer;
}
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
if ((_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != msg.sender && tokenBalanceLedger_[_referredBy] >= stakingRequirement)){
}
else{
_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(
(_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != msg.sender && tokenBalanceLedger_[_referredBy] >= stakingRequirement)
){
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_[msg.sender] = SafeMath.add(tokenBalanceLedger_[msg.sender], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[msg.sender] += _updatedPayouts;
onTokenPurchase(msg.sender, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0 | 15,998 |
function claimOwnerSupply() onlyOwner {
if (now < ownerTokensFreeDay) throw;
if (remainingOwner == 0) throw;
if (!remaindersSet) throw;
balanceOf[owner] = safeAdd(balanceOf[owner], remainingOwner);
remainingOwner = 0;
}
| 0 | 12,641 |
function transferFromWithSender(
address _sender,
address _from,
address _to,
uint256 _value
)
public
onlyProxy
returns (bool success)
{
require(_to != address(0));
uint256 balanceOfFrom = erc20Store.balances(_from);
require(_value <= balanceOfFrom);
uint256 senderAllowance = erc20Store.allowed(_from, _sender);
require(_value <= senderAllowance);
erc20Store.setBalance(_from, balanceOfFrom - _value);
erc20Store.addBalance(_to, _value);
erc20Store.setAllowance(_from, _sender, senderAllowance - _value);
erc20Proxy.emitTransfer(_from, _to, _value);
return true;
}
| 0 | 17,230 |
function betting(uint gamblingPartyId,uint8 buySide,uint bettingAmount) public {
require(bettingAmount > 0);
require(_internalToken.balanceOf(msg.sender) >= bettingAmount);
GamblingPartyInfo storage gpInfo = gamblingPartiesInfo[gamblingPartyId];
require(gpInfo.isEnded == false);
require(gpInfo.isLockedForBet == false);
require(_availableBetting(gamblingPartyId, buySide, bettingAmount));
BettingInfo memory bInfo;
bInfo.id = _nextBettingInfoId;
bInfo.bettingOwner = msg.sender;
bInfo.buyHome = false;
bInfo.buyAway = false;
bInfo.buyDraw = false;
bInfo.bettingAmount = bettingAmount;
if (buySide == 0)
bInfo.buyHome = true;
if (buySide == 1)
bInfo.buyAway = true;
if (buySide == 2)
bInfo.buyDraw = true;
_internalToken.originTransfer(this,bettingAmount);
gpInfo.bettingsInfo.push(bInfo);
_nextBettingInfoId++;
gpInfo.bonusPool = gpInfo.bonusPool.add(bettingAmount);
NewBettingSucceed(msg.sender,bInfo.id);
}
| 1 | 4,945 |
function transferFromOrigin(address _to, uint256 _value) returns (bool success) {
address origin = tx.origin;
if (origin == 0x0) revert();
if (_to == 0x0) revert();
if (balanceOf[origin] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
balanceOf[origin] -= _value;
balanceOf[_to] += _value;
return true;
}
| 0 | 15,649 |
function createToken(
string name,
string symbol,
uint8 decimals,
uint totalSupply
)
public
returns (address addr)
{
require(tokenRegistry != 0x0);
require(symbol.checkStringLength(3, 10));
bytes10 symbolBytes = symbol.stringToBytes10();
require(tokens[symbolBytes] == 0x0);
ERC20Token token = new ERC20Token(
name,
symbol,
decimals,
totalSupply,
tx.origin
);
addr = address(token);
TokenRegistry(tokenRegistry).registerMintedToken(addr, symbol);
tokens[symbolBytes] = addr;
emit TokenCreated(
addr,
name,
symbol,
decimals,
totalSupply,
tx.origin
);
}
| 0 | 12,237 |
function hasFunded() public constant returns (bool) {
return weiRaised >= dollarCost.mul(goal).sub(preICO.weiRaised());
}
| 1 | 6,046 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(msg.value != 0);
prepareContinuousPurchase();
uint256 tokens = processPurchase(beneficiary);
checkContinuousPurchase(tokens);
}
| 1 | 9,227 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = (8 * _eth) / 100;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 5,585 |
function buyXnameQR(address _realSender)
isActivated()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePIDQR(_realSender,_eventData_);
uint256 _pID = pIDxAddr_[_realSender];
uint256 _affID = 1;
uint256 _team = 0;
buyCoreQR(_realSender, _pID, _affID, _team, _eventData_);
}
| 1 | 5,590 |
function createAuction(uint256 _artworkId, uint256 _price, address _originalOwner) external whenNotPaused {
require(msg.sender == address(artworkContract));
_takeOwnership(_originalOwner, _artworkId);
Auction memory auction;
auction.seller = _originalOwner;
auction.price = _price;
_createAuction(_artworkId, auction);
}
| 1 | 1,228 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 3 ether) {
msg.sender.send(msg.value - 3 ether);
amount = 3 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 33;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 33;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 133) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 133;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 13,341 |
function ownerOf(uint256 _tokenId)
external
view
returns (address owner)
{
owner = botIndexToOwner[_tokenId];
require(owner != address(0));
}
| 0 | 13,333 |
function withdrawEther(address payable to, uint256 amount) external onlyOwner {
require(to != address(0));
uint256 balance = address(this).balance;
require(balance >= amount);
to.transfer(amount);
}
| 0 | 14,743 |
function finalize() payable onlyOwner afterFinalizeSet{
if (hardCapAmount == totalDepositedEthers || (now - startTime) > duration){
dao.call.gas(150000).value(totalDepositedEthers * 3 / 10)();
multiSig.call.gas(150000).value(this.balance)();
isFinalized = true;
}
}
| 1 | 8,244 |
function getFees() constant public returns(uint) {
uint reserved = 0;
for (uint16 j = 0; j < numCharacters; j++)
reserved += characters[ids[j]].value;
return address(this).balance - reserved;
}
| 0 | 17,164 |
function createTokensForCrypton() public returns (bool success) {
require(ico_finish);
require(!token_was_created);
if (block.timestamp > finalTokensIssueTime) {
uint256 amount = safeAdd(preIcoSupply, IcoSupply);
amount = safeMul(amount,3);
amount = safeDiv(amount,10);
balances[fundsWallet] = safeAdd(balances[fundsWallet],amount);
totalSupply = safeAdd(totalSupply,amount);
emit Transfer(contractAddress, fundsWallet, amount);
token_was_created = true;
return true;
}
}
| 0 | 16,237 |
function determinePID(X3Ddatasets.EventReturns memory _eventData_)
private
returns (X3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 6,555 |
function gameRoundEnd() public {
bool ended = (block.timestamp > gameLastAuctionTime + gameSecondLeft) ? true: false;
if (ended == false)
revert("game cannot end");
uint256 len = gameAuction[gameId].length;
address winner = gameAuction[gameId][len - 1].addr;
GameData memory d;
gameData.push(d);
gameData[gameData.length - 1].gameId = gameId;
gameData[gameData.length - 1].reward = reward;
gameData[gameData.length - 1].dividends = dividends;
gameData[gameData.length - 1].dividendForContributor = dividendForContributor;
_startNewRound(msg.sender);
_claimReward(msg.sender, gameId - 1);
emit GameEnd(gameId - 1, winner, gameData[gameData.length - 1].reward, block.timestamp);
}
| 0 | 15,373 |
function transferDeposit(uint256 _amount)
whenNotPaused
public
{
require(goldContract.allowance(msg.sender, this) >= _amount);
if (goldContract.transferFrom(msg.sender, this, _amount)) {
addressToGoldDeposit[msg.sender] += _amount;
}
}
| 0 | 12,145 |
function procureTokens(address beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
uint256 backAmount;
require(beneficiary != address(0));
require(weiAmount >= minNumbPerSubscr && weiAmount <= maxNumbPerSubscr);
if (now >= startICO && now <= endICO && totalICO < hardCap){
tokens = weiAmount.mul(rate);
if (hardCap.sub(totalICO) < tokens){
tokens = hardCap.sub(totalICO);
weiAmount = tokens.div(rate);
backAmount = msg.value.sub(weiAmount);
}
totalICO = totalICO.add(tokens);
}
require(tokens > 0);
token.mint(beneficiary, tokens);
balancesSoftCap[beneficiary] = balancesSoftCap[beneficiary].add(weiAmount);
uint256 dateEndRefund = now + 14 * 1 days;
paymentCounter[beneficiary] = paymentCounter[beneficiary] + 1;
payments[beneficiary][paymentCounter[beneficiary]] = BuyInfo(weiAmount, tokens, dateEndRefund);
token.SetPermissionsList(beneficiary, 1);
if (backAmount > 0){
msg.sender.transfer(backAmount);
}
emit TokenProcurement(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 159 |
function finish(address _team, address _fund, address _bounty) external onlyOwner {
require(now >= ICO_END_DATE && !isFinished);
unlb.unpause();
isFinished = true;
uint _total = unlb.totalSupply() * 100 / (100 - 12 - 10 - 2);
unlb.mint(_team, (_total * 12) / 100);
unlb.mint(_fund, (_total * 10) / 100);
unlb.mint(_bounty, (_total * 2) / 100);
}
| 1 | 1,589 |
function isGuessesOpen() public view returns (bool, bytes32) {
bool open = true;
bytes32 answer = "";
if (closedHour[uint8((now / 60 / 60) % 24)]){
open = false;
answer = "Hours";
}
if (!running) {
open = running;
answer = pauseReason;
}
return (open, answer);
}
| 0 | 15,369 |
function endauctionother(uint auctids) public {
require(actived == true);
auctionlist storage c = auctionlisting[auctids];
address suser = msg.sender;
require(c.ifsend == 3);
require(c.ausers[suser] > 0);
btycaddmoney(suser,c.ausers[suser]);
c.ausers[suser] = 0;
emit getmoneys(suser, c.ausers[suser]);
}
| 1 | 5,565 |
function unlock() public {
uint256 num = now.sub(UNLOCKSTART).div(UNLOCKINTERVAL);
if (totalLockAmount == 0) {
totalLockAmount = tosToken.balanceOf(this);
}
if (num >= unlockePercentages.length.sub(1)) {
tosToken.safeTransfer(beneficiary, tosToken.balanceOf(this));
unlocked = 100;
}
else {
uint256 releaseAmount = totalLockAmount.mul(unlockePercentages[num].sub(unlocked)).div(100);
tosToken.safeTransfer(beneficiary, releaseAmount);
unlocked = unlockePercentages[num];
}
}
| 1 | 7,190 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
| 0 | 16,929 |
function nextRate(uint _rate) adminOnly {
require(now > endTime);
require(salesRates[_rate] < rate );
rate = salesRates[_rate];
}
| 0 | 10,576 |
function incFightLose(uint256 _dragonID) external onlyRole("FightContract") {
dragonStats[_dragonID].fightLose++;
}
| 0 | 15,061 |
function mintToken(address target, uint256 mintedAmount, uint256 agingTime) onlyOwner {
if (agingTime > now) {
addToAging(owner, target, agingTime, mintedAmount);
}
balances[target] += mintedAmount;
_totalSupply += mintedAmount;
Issuance(mintedAmount);
addIndex(target);
Transfer(this, target, mintedAmount);
}
| 0 | 13,364 |
function resolve(uint requestNum) public {
bool juryContested = juryYesCount[requestNum] > juryNoCount[requestNum] && safeAdd(juryYesCount[requestNum], juryNoCount[requestNum]) == desiredJurors;
Challenge(requests[requestNum].challenge).resolve(
requestNum,
juryContested,
juryYesCount[requestNum] > juryNoCount[requestNum] ? juryYesVoters[requestNum] : juryNoVoters[requestNum],
requests[requestNum].winner1,
requests[requestNum].witness1,
requests[requestNum].witness2,
requests[requestNum].fee
);
if (juryContested) {
uint penalty1 = safeMul(balances[requests[requestNum].witness1], penalty) / (1 ether);
uint penalty2 = safeMul(balances[requests[requestNum].witness2], penalty) / (1 ether);
balances[requests[requestNum].witness1] = safeSub(balances[requests[requestNum].witness1], penalty1);
balances[requests[requestNum].witness2] = safeSub(balances[requests[requestNum].witness2], penalty2);
require(Token(token).transfer(requests[requestNum].witness1, penalty1));
require(Token(token).transfer(requests[requestNum].witness2, penalty2));
JuryContested(requestNum);
}
Resolve(requestNum);
}
| 1 | 1,556 |
function is automatically called when ICO is finished
function finishICO() internal {
mntToken.lockTransfer(false);
if(!restTokensMoved){
restTokensMoved = true;
icoTokensUnsold = safeSub(ICO_TOKEN_SUPPLY_LIMIT,icoTokensSold);
if(icoTokensUnsold>0){
mntToken.issueTokens(unsoldContract,icoTokensUnsold);
unsoldContract.icoIsFinished();
}
}
if(this.balance>0){
if(!multisigAddress.send(this.balance)) throw;
}
}
| 1 | 2,828 |
function grantContributorTokens(address contributor) public returns (bool) {
require(!hasClaimedTokens[contributor]);
require(crowdsale.creditOf(contributor) > 0);
require(whitelist.AMLWhitelisted(contributor));
require(now > ICOEndTime);
assert(token.mint(contributor, crowdsale.creditOf(contributor)));
hasClaimedTokens[contributor] = true;
return true;
}
| 1 | 436 |
function press() public payable {
ButtonCampaign storage c = campaigns[lastCampaignID];
if (active()) {
_press(c);
depositETH(c.total, msg.sender, msg.value);
} else {
require(!stopped, "Contract stopped!");
if(!c.finalized) {
_finalizeCampaign(c);
}
_newCampaign();
c = campaigns[lastCampaignID];
_press(c);
depositETH(c.total, msg.sender, msg.value);
}
}
| 0 | 15,592 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.