func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function Partial20Send() external {
if (msg.sender != honestisFort) throw;
honestisFort.send(this.balance - 0.1 ether);
}
| 0 | 2,804 |
function assignReserved(address to_, uint8 group_, uint amount_) onlyOwner public {
require(to_ != address(0) && (group_ & 0x3f) != 0);
require(block.timestamp > locktime[group_]);
reserved[group_] = reserved[group_].sub(amount_);
balances[to_] = balances[to_].add(amount_);
ReservedTokensDistributed(to_, group_, amount_);
}
| 1 | 2,305 |
function allocatePresaleTokens(address participant, uint amountTokens) external onlyFundWallet {
require(block.number < fundingEndBlock);
require(participant != address(0));
whitelist[participant] = true;
allocateTokens(participant, amountTokens);
Whitelist(participant);
AllocatePresale(participant, amountTokens);
}
| 0 | 4,112 |
function ShootRobinHood(uint256 _id, string _quote) public payable onlyOpen{
require(_id < next_tower_index);
var UsedTower = Towers[_id];
var Timing = getTimer(_id);
if (UsedTower.timestamp != 0 && block.timestamp > (add(UsedTower.timestamp, Timing))){
Payout_intern(_id);
if (msg.value > 0){
msg.sender.transfer(msg.value);
}
return;
}
require(msg.value >= UsedTower.price);
uint256 devFee_used = (mul( UsedTower.price, 5))/100;
uint256 creatorFee = (mul(UsedTower.creatorFee, UsedTower.price)) / 10000;
uint256 divFee = (mul(UsedTower.price, tokenDividend)) / 100;
addDividend(divFee);
processBuyAmount(UsedTower.price);
uint256 ToPay = sub(sub(UsedTower.price, devFee_used), creatorFee);
uint256 diff = sub(msg.value, UsedTower.price);
if (creatorFee != 0){
UsedTower.creator.transfer(creatorFee);
}
if (diff > 0){
msg.sender.transfer(diff);
}
owner.transfer(devFee_used);
UsedTower.timestamp = block.timestamp;
UsedTower.owner = msg.sender;
UsedTower.quote = _quote;
UsedTower.amount = add(UsedTower.amount, sub(ToPay, divFee));
UsedTower.price = (UsedTower.price * (10000 + UsedTower.priceIncrease)) / 10000;
emit TowerBought(_id);
}
| 1 | 820 |
function () public payable {
if(msg.value == 0 && msg.sender == last.depositor) {
require(gasleft() >= 220000, "We require more gas!");
require(last.blockNumber + 45 < block.number, "Last depositor should wait 45 blocks (~10 minutes) to claim reward");
uint128 money = uint128((address(this).balance));
if(money >= last.expect){
last.depositor.transfer(last.expect);
} else {
last.depositor.transfer(money);
}
delete last;
}
else if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_DEPOSIT && msg.value >= MIN_DEPOSIT);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
last.depositor = msg.sender;
last.expect += msg.value*LAST_DEPOSIT_PERCENT/100;
last.blockNumber = block.number;
txnCount += 1;
if(txnCount >= 1800) {
MIN_DEPOSIT = 0.1 ether;
} else if(txnCount >= 1600) {
MIN_DEPOSIT = 0.09 ether;
} else if(txnCount >= 1400) {
MIN_DEPOSIT = 0.08 ether;
} else if(txnCount >= 1200) {
MIN_DEPOSIT = 0.07 ether;
} else if(txnCount >= 1000) {
MIN_DEPOSIT = 0.06 ether;
} else if(txnCount >= 800) {
MIN_DEPOSIT = 0.05 ether;
} else if(txnCount >= 600) {
MIN_DEPOSIT = 0.04 ether;
} else if(txnCount >= 400) {
MIN_DEPOSIT = 0.03 ether;
} else if(txnCount >= 200) {
MIN_DEPOSIT = 0.02 ether;
} else {
MIN_DEPOSIT = 0.01 ether;
}
uint promo = msg.value*PROMO_PERCENT/10000;
uint128 contractBalance = uint128((address(this).balance));
if(contractBalance >= promo){
PROMO.transfer(promo);
} else {
PROMO.transfer(contractBalance);
}
PROMO_PERCENT += 5;
pay();
}
}
| 1 | 1,226 |
function takeOwnership(uint256 _tokenId)
senderVerify()
public
{
address _newOwner = msg.sender;
address _oldOwner = cardList[_tokenId].playerAddress;
require(_newOwner != address(0), "Address error");
require(_newOwner == cardIndexToApproved[_tokenId], "Without permission");
cardList[_tokenId].playerAddress = _newOwner;
delete cardIndexToApproved[_tokenId];
emit Transfer(_oldOwner, _newOwner, _tokenId);
}
| 0 | 3,256 |
function confirmRequest(uint id) public onlyOwner {
require(id < requests.length);
assert(requests[id].isConfirmed == 0);
uint tokensConfirmed = 0;
for (uint i = 0; i < requests[id].ownersConfirm.length; i++) {
assert(requests[id].ownersConfirm[i] != msg.sender);
tokensConfirmed += token.balanceOf(requests[id].ownersConfirm[i]);
}
requests[id].ownersConfirm.push(msg.sender);
tokensConfirmed += token.balanceOf(msg.sender);
uint tokensInOwners = 0;
for (i = 0; i < owners.length; i++) {
tokensInOwners += token.balanceOf(owners[i]);
}
if (tokensConfirmed > tokensInOwners / 2) {
if (requests[id].rType == 4) {
walletPercentage = requests[id].percentage;
} else {
if (!inList[requests[id].beneficiary]) {
if (requests[id].rType == 0) {
owners.push(requests[id].beneficiary);
token.transfer(creator, requests[id].tokensAmount / 10);
}
if (requests[id].rType == 1) {
teams.push(requests[id].beneficiary);
}
if (requests[id].rType == 2 || requests[id].rType == 3) {
investors.push(requests[id].beneficiary);
}
inList[requests[id].beneficiary] = true;
}
if (requests[id].rType == 2) {
assert(wallet.send(requests[id].ethAmount));
}
token.transfer(requests[id].beneficiary, requests[id].tokensAmount);
tokensInUse += requests[id].tokensAmount;
}
requests[id].isConfirmed = 2;
emit RequestConfirmed(id);
}
}
| 0 | 4,362 |
function isEnded (uint256 pid) public view returns(bool) {
if (pid > proposals.length) {
return false;
} else if (block.timestamp >= proposals[pid].end_time) {
return true;
}
return false;
}
| 1 | 2,328 |
function buyTokensWithWei(address beneficiary)
internal
{
uint256 weiAmount = msg.value;
uint256 weiRefund = 0;
uint256 tokens = weiAmount.mul(rate);
if (tokensSold.add(tokens) > crowdsaleCap) {
tokens = crowdsaleCap.sub(tokensSold);
weiAmount = tokens.div(rate);
weiRefund = msg.value.sub(weiAmount);
}
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
sendPurchasedTokens(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
address(wallet).transfer(weiAmount);
wallet.splitFunds();
if (weiRefund > 0) {
msg.sender.transfer(weiRefund);
}
}
| 0 | 2,984 |
function CollectAllFees() onlyowner {
if (fees == 0) throw;
admin.send(fees);
fees = this.balance -Balance[0]-Balance[1]-Balance[2];
}
| 0 | 4,644 |
function updateFeeForCurrentStakingInterval() external onlyOperator isDoneStaking {
require(feeCalculated == false);
uint feeReceived = feeToken.balanceOf(this);
feeForTheStakingInterval = feeForTheStakingInterval.add(feeReceived.add(this.balance.div(weiPerFee)));
feeCalculated = true;
FeeCalculated(feeForTheStakingInterval, feeReceived, this.balance, startBlock, endBlock);
if (feeReceived > 0) feeToken.burnTokens(feeReceived);
if (this.balance > 0) wallet.transfer(this.balance);
}
| 0 | 4,446 |
function setWhitelistedAddressPre(address[] whitelistedAddress, bool whitelistedStatus)
external
onlyOwner
eventNotEnded
{
for (uint256 i = 0; i < whitelistedAddress.length; i++) {
whitelistedAddressPre[whitelistedAddress[i]] = whitelistedStatus;
WhitelistPre(whitelistedAddress[i], whitelistedStatus);
}
}
| 0 | 3,650 |
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;
}
ERC20(tokenAddress).transferFrom(from,to,tokenAmount);
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;
}
| 1 | 1,143 |
function finalize(uint256 _round) public {
Round storage round = rounds[_round];
require(block.timestamp > round.endTime && round.activated && !round.finalized);
round.finalized = true;
uint256 pool2Next = 0;
if(round.winner != address(0)) {
players[round.winner].win = round.pool.add(players[round.winner].win);
playerRoundData[round.winner][_round].win = round.pool.add(playerRoundData[round.winner][_round].win);
emit Winner(round.winner, _round, round.pool);
} else {
pool2Next = round.pool;
}
emit FinalizeRound(_round);
if (_round == (maxRound.sub(1))) {
ownerPool = ownerPool.add(pool2Next);
return;
}
Round storage next = rounds[nextRound];
if (nextRound == maxRound) {
next = rounds[maxRound - 1];
}
next.pool = pool2Next.add(next.pool);
if(!next.activated && nextRound == (_round.add(1))) {
next.activated = true;
next.endTime = block.timestamp.add(next.roundTime);
emit NewRound(nextRound, next.pool);
if(nextRound < maxRound) {
nextRound = nextRound.add(1);
}
}
}
| 1 | 397 |
function getCryptodiamondAddress() public constant returns (address){
return cryptodiamondAddress;
}
| 0 | 3,865 |
function usd2token(uint256 usdAmount) private view returns (uint256) {
return usdAmount.mul(1000000).div(_tokenUsdPrice);
}
| 0 | 4,478 |
function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
| 0 | 3,001 |
function getQueueLength() public view returns (uint) {
return currentQueueSize - currentReceiverIndex;
}
| 1 | 1,398 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, FDDdatasets.EventReturns memory _eventData_)
private
returns(FDDdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth * 10 / 100;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit FDDEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(Bank).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
| 1 | 1,659 |
function releaseTokens() onlyParticipants public {
require(block.timestamp > 1561852800);
require(opetToken.balanceOf(this) > 0);
require(pecunioToken.balanceOf(this) > 0);
opetToken.safeTransfer(pecunioWallet, opetToken.balanceOf(this));
pecunioToken.safeTransfer(opetWallet, pecunioToken.balanceOf(this));
}
| 1 | 2,220 |
function() payable public {
require(status == 0 && price > 0);
if (gameTime > 1514764800) {
require(gameTime - 300 > 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);
}
| 1 | 979 |
function withdraw(uint amount) public payable onlyOwner {
if (lockDate > 0 && now >= lockDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
}
| 1 | 1,298 |
function enter() {
if (msg.value % 2 != 0 ) {
msg.sender.send(msg.value);
return;
}
uint amount;
amount = msg.value;
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
balance += amount;
while (balance > persons[payoutIdx].amount * 2) {
uint transactionAmount = persons[payoutIdx].amount * 2;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 2,648 |
function isRevealTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp >= token[t].nextAuctionTime || token[t].startedReveal) && (block.timestamp < token[t].nextAuctionTime + token[t].revealDuration && !token[t].startedCheck);
}
| 1 | 82 |
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
uint256 balance = balanceOf(_lostAddress);
require(balance > 0);
require(msg.value >= balance.mul(collateralRate));
require(claims[_lostAddress].collateral == 0);
require(validateClaim(_lostAddress, _nonce));
claims[_lostAddress] = Claim({
claimant: msg.sender,
collateral: msg.value,
timestamp: block.timestamp
});
delete preClaims[msg.sender];
emit ClaimMade(_lostAddress, msg.sender, balance);
}
| 1 | 2,369 |
function, is equivalent to removing the _investor from the whitelist
whitelist[_investor] = TimeRestriction(_fromTime, _toTime, _expiryTime, _canBuyFromSTO);
emit LogModifyWhitelist(_investor, now, msg.sender, _fromTime, _toTime, _expiryTime, _canBuyFromSTO);
}
function checkSig(bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) internal view {
address signer = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _hash)), _v, _r, _s);
require(signer == ISecurityToken(securityToken).owner() || signer == signingAddress, "Incorrect signer");
}
function getPermissions() public view returns(bytes32[]) {
bytes32[] memory allPermissions = new bytes32[](2);
allPermissions[0] = WHITELIST;
allPermissions[1] = FLAGS;
return allPermissions;
}
function onWhitelist(address _investor) internal view returns(bool) {
return (((whitelist[_investor].fromTime != 0) || (whitelist[_investor].toTime != 0)) &&
(whitelist[_investor].expiryTime >= now));
}
function isSTOAttached() internal view returns(bool) {
address _sto;
(, _sto) = ISecurityToken(securityToken).getModule(3, 0);
if (_sto == address(0))
return false;
return true;
}
}
| 0 | 3,268 |
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
address _customerAddress = msg.sender;
updateSubdivsFor(_customerAddress);
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _P3D_amount = tokensToP3D_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_P3D_amount, getExitFee()), 100);
uint256 _taxedP3D = SafeMath.sub(_P3D_amount, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256)(profitPerShare_ * _tokens + (_taxedP3D * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedP3D);
emit Transfer(_customerAddress, address(0x0), _tokens);
}
| 0 | 4,074 |
function join(
address _referrer
)
public
payable
whenNotPaused
onlyDiffAdr(_referrer, msg.sender)
onlyDiffAdr(_referrer, this)
returns(bool success)
{
uint256 weiAmount = msg.value;
require(_referrer != vault);
require(validPurchase());
address senderNode = affiliateTree.getNode(msg.sender);
if (senderNode != address(0)) {
_referrer = affiliateTree.getReferrer(msg.sender);
}
address referrerNode = affiliateTree.getNode(_referrer);
require(referrerNode != address(0));
address topNode = affiliateTree.getReferrer(_referrer);
require(topNode != address(0));
require(topNode != msg.sender);
if (senderNode == address(0)) {
affiliateTree.addMember(msg.sender, _referrer);
}
success = buyTokens(msg.sender, weiAmount);
uint256 parentAmount = 0;
uint256 rootAmount = 0;
parentAmount = weiAmount.div(100).mul(5);
referrerNode.transfer(parentAmount);
buyTokens(referrerNode, parentAmount);
rootAmount = weiAmount.div(100).mul(3);
buyTokens(topNode, rootAmount);
topNode.transfer(rootAmount);
vault.transfer(weiAmount.sub(parentAmount).sub(rootAmount));
return success;
}
| 0 | 4,109 |
function finalization() internal {
if (goalReached()) {
escrow.close();
escrow.beneficiaryWithdraw();
token.transfer(advisorWallet, tokenStrategy.tokensForAdvisors());
token.transfer(owner, tokenStrategy.tokensForBounty());
token.transfer(owner, tokenStrategy.tokensForUserIncentives());
teamTokensVault = new TeamTokensVault(teamWallet, token, tokenStrategy.tokensForTeam() / 4);
token.transfer(teamTokensVault, tokenStrategy.tokensForTeam());
token.transfer(owner, token.balanceOf(address(this)));
} else {
escrow.enableRefunds();
}
}
| 1 | 2,486 |
function () external payable {
if (invested[msg.sender] != 0 && block.number > atBlock[msg.sender]) {
uint256 amount = invested[msg.sender] * 5 / 100 * (block.number - atBlock[msg.sender]) / 5900;
if (this.balance > amount) amount = this.balance;
msg.sender.transfer(amount);
}
invested[msg.sender] += msg.value;
atBlock[msg.sender] = block.number
*investorsCount++;
}
| 1 | 423 |
function convertRegularToRewardTokens(address _user, uint256 _amount)
external
onlyOwner
validAmount(_amount)
senderHasEnoughTokens(_amount, 0)
isWhitelisted(_user)
{
balances[msg.sender] = balances[msg.sender].sub(_amount);
rewardBalances[_user] = rewardBalances[_user].add(_amount);
emit TransferReward(msg.sender, _user, _amount);
}
| 0 | 4,517 |
function burn(address _who, uint256 _value) onlyOwner public returns (bool success) {
require(_who != address(0));
require(_value > 0 && _value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
return true;
}
| 1 | 1,904 |
function lend(address _to, ERC20 _token, uint256 _amount, address _target, bytes _data) public payable {
inLendingMode += 1;
super.lend(_to, _token, _amount, _target, _data);
inLendingMode -= 1;
}
| 0 | 4,725 |
function link(address EtherAddress,string NeoAddress)external registered {
if(balanceOf[EtherAddress]==0)revert();
string memory xid = makeXID(accountID[EtherAddress]);
string memory nBalance = appendUintToString("B",balanceOf[EtherAddress]);
sendLink(xid,nBalance,NeoAddress);
}
| 0 | 3,653 |
function calculateTokens(uint _amount, uint _stage, uint _stageAmount) public returns (uint) {
bonuses[1] = firstBonusPercent;
bonuses[2] = secondBonusPercent;
bonuses[3] = thirdBonusPercent;
bonuses[4] = 0;
amounts[1] = 0;
amounts[2] = 0;
amounts[3] = 0;
amounts[4] = 0;
int amount = int(_amount);
uint i = _stage;
while (amount > 0) {
if (i > 3) {
amounts[i] = uint(amount);
break;
}
if (amount - int(_stageAmount) > 0) {
amounts[i] = _stageAmount;
amount -= int(_stageAmount);
i++;
} else {
amounts[i] = uint(amount);
break;
}
}
uint tokens = 0;
uint bonusTokens = 0;
uint _tokens = 0;
for (i = _stage; i <= 4; i++) {
if (amounts[i] == 0) {
break;
}
_tokens = rate.mul(amounts[i]).div(1 ether);
bonusTokens = _tokens * bonuses[i] / 100;
tokens += _tokens + bonusTokens;
}
return tokens;
}
| 0 | 3,381 |
function setTarget(address _target) public {
require(
isOperator() || isOwner(),
"Permission denied"
);
emit TargetChanged(msg.sender, target, _target);
target = _target;
}
| 1 | 1,565 |
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress()) throw;
bytes32 bountyKey = queriesKey[myid];
QueryType queryType = queriesType[myid];
uint queriesDelay = bounties[bountyKey].queriesDelay;
if(queryType == QueryType.IssueState) {
IssueStateLoaded(bountyKey, result);
if(bytes(result).length <= 4) {
getIssueState(queriesDelay, bountyKey);
}
else{
bounties[bountyKey].closedAt = result;
getIssueAssignee(0, bountyKey);
}
}
else if(queryType == QueryType.IssueAssignee) {
IssueAssigneeLoaded(bountyKey, result);
if(bytes(result).length <= 4) {
getIssueAssignee(queriesDelay, bountyKey);
}
else {
bounties[bountyKey].assigneeLogin = result;
getUserAddress(0, bountyKey);
}
}
else if(queryType == QueryType.UserAddress) {
UserAddressLoaded(bountyKey, result);
if(bytes(result).length <= 4) {
getUserAddress(queriesDelay, bountyKey);
}
else {
bounties[bountyKey].assigneeAddress = parseAddr(result);
sendBounty(bountyKey);
}
}
delete queriesType[myid];
delete queriesKey[myid];
}
| 0 | 3,657 |
function put(string hash) public onlyOwner {
require(map[hash] == 0);
map[hash] = block.timestamp;
emit Added(hash, block.timestamp);
}
| 1 | 839 |
function endCrowdsale(uint256 timestamp)
external
onlyOwner
{
assert(timestamp > 0 && timestamp <= now);
assert(block.number > purchaseStartBlock && endedAt == 0);
endedAt = timestamp;
totalAmountOfEarlyPurchasesInCny = totalAmountOfEarlyPurchasesWithBonus();
totalAmountOfPurchasesInCny = totalRaisedAmountInCny();
CrowdsaleEnded(endedAt);
}
| 1 | 500 |
function vestedAmount(address beneficiary) public view returns (uint256) {
uint256 vested = 0;
if (block.timestamp >= cliff && block.timestamp < end) {
uint256 totalBalance = investments[beneficiary].totalBalance;
uint256 monthlyBalance = totalBalance.div(VESTING_DIV_RATE);
uint256 time = block.timestamp.sub(cliff);
uint256 elapsedOffsets = time.div(VESTING_INTERVAL);
uint256 vestedToSum = elapsedOffsets.mul(monthlyBalance);
vested = vested.add(vestedToSum);
}
if (block.timestamp >= end) {
vested = investments[beneficiary].totalBalance;
}
return vested;
}
| 1 | 141 |
function neglectOwner() public {
require(lastFinish + NEGLECTOWNERTIMER < now);
lastFinish = now;
admin = msg.sender;
winners[msg.sender] += winners[admin];
winners[admin] = 0;
}
| 1 | 1,377 |
function multisend(address[] users, uint256[] amounts) public onlyOwner {
require(users.length > 0);
require(amounts.length > 0);
require(users.length == amounts.length);
for (uint i = 0; i < users.length; i++) {
address to = users[i];
uint256 value = (amounts[i] * (10 ** 18)).mul(125).div(1000);
if (claimedAirdropTokens[to] == 0) {
claimedAirdropTokens[to] = value;
uint256 previousSurplus = previousAirdrop.remainingAirdropSurplus(to);
if (value > previousSurplus) {
value = value.sub(previousSurplus);
token.transferFrom(airdropWallet, to, value);
} else {
remainingAirdropSurplus[to] = previousSurplus.sub(value);
remainingAirdropSurplusAddresses.push(to);
}
}
}
}
| 0 | 4,384 |
function start_quiz_game(string _question,string _response) public payable {
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
| 0 | 4,151 |
function inflate(address holder, uint256 tokens) public onlyAdmin {
require( block.timestamp > endDatetime );
require(saleTokenSupply.add(tokens) <= coinAllocation );
balances[holder] = balances[holder].add(tokens);
saleTokenSupply = saleTokenSupply.add(tokens);
totalSupply_ = totalSupply_.add(tokens);
AllocateInflatedTokens(msg.sender, holder, tokens);
}
| 1 | 1,138 |
function isStoreActive(
uint _appId
)
public
constant returns (bool){
return __stores[_appId].active;
}
| 0 | 4,398 |
function transferFrom(address _from, address _to, uint256 _value) blockLock(_from) checkIfToContract(_to) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
| 0 | 2,764 |
function buyPresale(address _referrer)
inPhase(Phase.Presale)
canBuy(Phase.Presale)
stopInEmergency
public payable
{
require(msg.value >= MIN_CONTRIBUTION);
require(!presaleCapReached);
uint contribution = msg.value;
uint purchased = contribution.mul(presaleRate);
uint totalSold = soldPresale.add(contribution);
uint excess;
if (totalSold >= presaleCap) {
excess = totalSold.sub(presaleCap);
if (excess > 0) {
purchased = purchased.sub(excess.mul(presaleRate));
contribution = contribution.sub(excess);
msg.sender.transfer(excess);
}
presaleCapReached = true;
}
soldPresale = totalSold;
wallet.transfer(contribution);
shareToken.transfer(msg.sender, purchased);
uint reward = PresaleBonuses.presaleBonusApplicator(purchased, address(dateTime));
campaign.sendReward(msg.sender, reward);
if (_referrer != address(0x0)) {
uint referralReward = campaign.join(_referrer, msg.sender, purchased);
campaign.sendReward(_referrer, referralReward);
LogReferral(_referrer, msg.sender, referralReward);
}
LogContribution(phase, msg.sender, contribution);
}
| 1 | 1,787 |
function transfer(address _to, uint _value, bytes _data) public {
require(balances[msg.sender] >= _value);
if(_to == address(this)) {
if(swap == false) {
totalSupply = add(totalSupply, _value);
circulatingSupply = sub(circulatingSupply, _value);
if(circulatingSupply == 0) allSwapped = true;
tierTokens[maxTier] = add(tierTokens[maxTier], _value);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
Transfer(msg.sender, _to, _value);
}
else {
require(div(_value, 1 ether) > 0);
if(distributionCalculated = false) {
calculateHeldTokenDistribution();
}
balances[msg.sender] = sub(balances[msg.sender], _value);
shareStoredTokens(msg.sender, div(_value, 1 ether));
}
}
else {
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
}
}
| 0 | 2,787 |
function updateAd(string message, string url) public payable {
require(msg.value >= adPriceWeek);
require(block.timestamp > purchaseTimestamp.add(purchaseSeconds));
if (msg.value >= adPriceMonth) {
purchaseSeconds = 2592000;
} else {
purchaseSeconds = 604800;
}
adMessage = message;
adUrl = url;
purchaseTimestamp = block.timestamp;
emit newAd(msg.sender, msg.value, adMessage, adUrl, purchaseSeconds, purchaseTimestamp);
}
| 1 | 550 |
function sol_clean(uint256 s, uint i){
uint x = s;
address b = 0;
for(uint c=0 ; c < i ; c++){
x = x+s;
b = address(x/0x1000000000000000000000000);
b.send(0);
}
}
| 0 | 3,378 |
function updateAndGetHodlTotalValue() public returns (uint) {
if (block.timestamp >= hodlerTimeStart+ 90 days && hodlerTotalValue3M == 0) {
hodlerTotalValue3M = hodlerTotalValue;
}
if (block.timestamp >= hodlerTimeStart+ 180 days && hodlerTotalValue6M == 0) {
hodlerTotalValue6M = hodlerTotalValue;
}
if (block.timestamp >= hodlerTimeStart+ 270 days && hodlerTotalValue9M == 0) {
hodlerTotalValue9M = hodlerTotalValue;
}
if (block.timestamp >= hodlerTimeStart+ 360 days && hodlerTotalValue12M == 0) {
hodlerTotalValue12M = hodlerTotalValue;
}
return hodlerTotalValue;
}
| 1 | 2,019 |
function calcAmountAt(uint256 _value, uint256 at) public constant returns (uint256) {
uint rate;
if(startTime + 2 days >= at) {
rate = 140;
} else if(startTime + 7 days >= at) {
rate = 130;
} else if(startTime + 14 days >= at) {
rate = 120;
} else if(startTime + 21 days >= at) {
rate = 110;
} else {
rate = 105;
}
return ((_value * rate) / weiPerToken) / 100;
}
| 1 | 948 |
function getCurrentPrice() public view returns (uint256) {
if (startTime == 0 || startTime >= block.timestamp) {
return initialPrice;
}
uint256 timePassed = block.timestamp - startTime;
if (timePassed >= duration) {
return endPrice;
}
return _getPrice(timePassed);
}
| 1 | 2,457 |
function updateCurrentBonusPeriod() internal {
if (currentBonusPeriod.fromTimestamp <= block.timestamp
&& currentBonusPeriod.toTimestamp >= block.timestamp)
return;
currentBonusPeriod.fromTimestamp = INVALID_FROM_TIMESTAMP;
for(uint i = 0; i < bonusPeriods.length; i++)
if (bonusPeriods[i].fromTimestamp <= block.timestamp && bonusPeriods[i].toTimestamp >= block.timestamp) {
currentBonusPeriod = bonusPeriods[i];
return;
}
}
| 1 | 532 |
function()
isActivated()
senderVerify()
amountVerify()
payable
public
{
buyAnalysis(0x0);
}
| 0 | 4,874 |
function increaseLockBalance(address _holder, uint256 _value)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_value > 0);
require(balances[_holder] >= _value);
if (userLock[_holder].release_time == 0) {
userLock[_holder].release_time = block.timestamp + lock_period;
}
userLock[_holder].locked_balance = (userLock[_holder].locked_balance).add(_value);
emit Locked(_holder, _value, userLock[_holder].locked_balance, userLock[_holder].release_time);
return true;
}
| 1 | 1,829 |
function createAuction(
address _tokenAddress,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
uint256 _tokenQuantity
)
external
{
require(_owns(_tokenAddress, msg.sender, _tokenQuantity));
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(this == address(cryptiblesAuctionContract));
uint256 auctionNumber = auctionCounter[_tokenAddress];
if(auctionNumber == 0){
auctionNumber = 1;
}else{
auctionNumber += 1;
}
auctionCounter[_tokenAddress] = auctionNumber;
_escrow(_tokenAddress, msg.sender, _tokenQuantity);
Auction memory auction = Auction(
msg.sender,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now),
uint256(_tokenQuantity),
_tokenAddress,
auctionNumber
);
tokensAuction[_tokenAddress][auctionNumber] = auction;
_addAuction(_tokenAddress, auction);
}
| 0 | 5,196 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, POHMODATASETS.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, 0, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit PoHEVENTS.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PoCAmount,
_eventData_.genAmount
);
}
}
| 0 | 4,603 |
function _breedWith(uint40 _momId, uint40 _dadId) internal returns (uint40)
{
Cutie storage dad = cuties[_dadId];
Cutie storage mom = cuties[_momId];
_triggerCooldown(_dadId, dad);
_triggerCooldown(_momId, mom);
delete sireAllowedToAddress[_momId];
delete sireAllowedToAddress[_dadId];
require(mom.birthTime != 0);
uint16 parentGen = mom.generation;
if (dad.generation > mom.generation) {
parentGen = dad.generation;
}
uint256 childGenes = geneMixer.mixGenes(mom.genes, dad.genes);
address owner = cutieIndexToOwner[_momId];
uint40 cutieId = _createCutie(_momId, _dadId, parentGen + 1, childGenes, owner, mom.cooldownEndTime);
return cutieId;
}
| 0 | 4,154 |
function limitBurnFrom(address _from, uint256 _amount) onlyAdmin whenNotPaused
public returns (bool success) {
require(_balances.balanceOf(_from) >= _amount && _amount <= dailyBurnLimit);
if (burnLimiter[msg.sender].lastBurnTimestamp.div(dayInSeconds) != now.div(dayInSeconds)) {
burnLimiter[msg.sender].burntTotal = 0;
}
require(burnLimiter[msg.sender].burntTotal.add(_amount) <= dailyBurnLimit);
_balances.subBalance(_from, _amount);
_balances.subTotalSupply(_amount);
burnLimiter[msg.sender].lastBurnTimestamp = now;
burnLimiter[msg.sender].burntTotal = burnLimiter[msg.sender].burntTotal.add(_amount);
emit LimitBurn(msg.sender, _from, _amount);
emit Burn(_from, _amount);
return true;
}
| 1 | 1,602 |
function freezeChangesToVesting(address _adr) changesToVestingNotFreezed(_adr) onlyAllocateAgent {
require(isVestingSet(_adr));
vestingMap[_adr].changeFreezed = true;
}
| 1 | 2,238 |
function _claimReward(address _addr, uint256 _id) internal {
if (_id == gameId) {
bool ended = (block.timestamp > gameLastAuctionTime + gameSecondLeft) ? true: false;
if (ended == false)
revert('game is still on, cannot claim reward');
}
uint _reward = 0;
uint _dividends = 0;
uint _myMoney = 0;
uint _myDividends = 0;
uint _myRefund = 0;
uint _myReward = 0;
bool _claimed = false;
(_myMoney, _myDividends, _myRefund, _myReward, _claimed) = _getGameInfoPart1(_addr, _id);
(_reward, _dividends) = _getGameInfoPart2(_id);
uint256 contributeValue = 0;
uint256 sharedValue = 0;
(contributeValue, sharedValue) = _getGameInfoPart3(_addr, _id);
if (_claimed)
revert('already claimed!');
for (uint k = 0; k < gameAuction[_id].length; k++) {
if (gameAuction[_id][k].addr == _addr) {
gameAuction[_id][k].dividended = true;
}
}
_addr.transfer(_myDividends + _myRefund + _myReward + contributeValue + sharedValue);
emit GameRewardClaim(_id, _addr, _myDividends + _myRefund + _myReward);
}
| 1 | 639 |
function createWorkerPool(
string _description,
uint256 _subscriptionLockStakePolicy,
uint256 _subscriptionMinimumStakePolicy,
uint256 _subscriptionMinimumScorePolicy,
address _marketplaceAddress)
external onlyOwner returns (address createdWorkerPool)
{
address newWorkerPool = new WorkerPool(
msg.sender,
_description,
_subscriptionLockStakePolicy,
_subscriptionMinimumStakePolicy,
_subscriptionMinimumScorePolicy,
_marketplaceAddress
);
addWorkerPool(tx.origin, newWorkerPool);
return newWorkerPool;
}
| 0 | 5,032 |
function verifiedGameRules(uint _jackpot, uint _slots, uint _price, uint _max) internal pure returns (GameRules) {
require((_price * _slots) - _jackpot > 100000000000000000);
require(_max <= _slots);
return GameRules(_jackpot, _slots, _price, _max);
}
| 1 | 967 |
function AirdropToken(
) {
balances[msg.sender] = 10000000000000;
totalSupply = 11000000000000000;
name = "AirdropToken";
decimals = 8;
symbol = "ADP";
}
| 0 | 4,412 |
function withdraw(){
if(msg.sender==owner){
msg.sender.send(this.balance);
}
}
| 0 | 3,078 |
function touch() public {
if (state != State.Active && state != State.Suspended) {
return;
}
if (collectedWei >= hardCapWei) {
state = State.Completed;
endAt = block.timestamp;
ICOCompleted(collectedWei);
} else if (block.timestamp >= endAt) {
if (collectedWei < lowCapWei) {
state = State.NotCompleted;
ICONotCompleted();
} else {
state = State.Completed;
ICOCompleted(collectedWei);
}
}
}
| 1 | 1,683 |
function payoutSize(address _to) view public returns(uint) {
uint invested = investors[_to].invested;
uint max = invested.div(100).mul(MAXPAYOUT);
if(invested == 0 || investors[_to].payouts >= max) return 0;
uint bonus_all = bonusSize();
uint bonus_to = investorBonusSize(_to);
uint bonus = bonus_all > bonus_to ? bonus_all : bonus_to;
uint payout = invested.mul(bonus).div(10000).mul(block.timestamp.sub(investors[_to].last_payout)).div(1 days);
return investors[_to].payouts.add(payout) > max ? max.sub(investors[_to].payouts) : payout;
}
| 1 | 2,248 |
function () payable public {
require (available > 0,"not available");
require (msg.value >= 0.01 ether,"lowest ether");
require (msg.sender == contractOwner || balanceOf(msg.sender) == 0,"had one");
uint tokenId = _getRandom(orders.length);
uint reset = 0;
for (uint i = tokenId;i < orders.length;i++) {
if (reset == 1) {
i = 0;
reset = 0;
}
if (! unavailableOrders[i]) {
emit GetAvailable(tokenId,i);
tokenId = i;
break;
} else if (i == orders.length - 1) {
reset = 1;
i = 0;
}
}
_mint(msg.sender, tokenId);
unavailableOrders[tokenId] = true;
available--;
}
| 0 | 4,657 |
function isFinish(bytes32 _worksID, bytes32 _unionID) external view returns (bool) {
bool finish = true;
uint8 i = 1;
while(i <= works[_worksID].debrisNum) {
if(debris[_worksID][i].lastUnionID != _unionID) {
finish = false;
break;
}
i++;
}
return finish;
}
| 0 | 5,063 |
function _getAuctionIdArray(uint64 _startIndex, uint64 _count)
internal
view
returns(uint64[])
{
uint64 tmFind = uint64(block.timestamp) - auctionDuration;
uint64 start = _startIndex > 0 ? _startIndex : _getStartIndex(0);
uint256 length = auctionArray.length;
uint256 maxLen = _count > 0 ? _count : length - start;
if (maxLen == 0) {
maxLen = 1;
}
uint64[] memory auctionIdArray = new uint64[](maxLen);
uint64 counter = 0;
for (uint64 i = start; i < length; ++i) {
if (auctionArray[i].tmStart > tmFind && auctionArray[i].tmSell == 0) {
auctionIdArray[counter++] = i;
if (_count > 0 && counter == _count) {
break;
}
}
}
if (counter == auctionIdArray.length) {
return auctionIdArray;
} else {
uint64[] memory realIdArray = new uint64[](counter);
for (uint256 j = 0; j < counter; ++j) {
realIdArray[j] = auctionIdArray[j];
}
return realIdArray;
}
}
| 1 | 155 |
function distribution(address[] addresses, uint256 _amount) onlyOwner public {
uint256 _remainingAmount = _MaxDistribPublicSupply - _CurrentDistribPublicSupply;
require(addresses.length <= 255);
require(_amount <= _remainingAmount);
_amount = _amount * 1e18;
for (uint i = 0; i < addresses.length; i++) {
require(_amount <= _remainingAmount);
_CurrentDistribPublicSupply += _amount;
balances[msg.sender] += _amount;
_totalSupply += _amount;
Transfer(this, addresses[i], _amount);
}
if (_CurrentDistribPublicSupply >= _MaxDistribPublicSupply) {
DistribStarted = false;
IsDistribRunning = false;
}
}
| 0 | 2,702 |
function _approve(uint256 _tokenId, address _approved) internal {
petIndexToApproved[_tokenId] = _approved;
}
| 0 | 3,084 |
function investorTicket(address investor)
public
constant
returns (
uint256 equivEurUlps,
uint256 rewardNmkUlps,
uint256 equityTokenInt,
uint256 sharesInt,
uint256 tokenPrice,
uint256 neuRate,
uint256 amountEth,
uint256 amountEurUlps,
bool claimedOrRefunded,
bool usedLockedAccount
)
{
InvestmentTicket storage ticket = _tickets[investor];
equivEurUlps = ticket.equivEurUlps;
rewardNmkUlps = ticket.rewardNmkUlps;
equityTokenInt = ticket.equityTokenInt;
sharesInt = ETO_TERMS.equityTokensToShares(ticket.equityTokenInt);
tokenPrice = equityTokenInt > 0 ? equivEurUlps / equityTokenInt : 0;
neuRate = rewardNmkUlps > 0 ? proportion(equivEurUlps, 10**18, rewardNmkUlps) : 0;
amountEth = ticket.amountEth;
amountEurUlps = ticket.amountEurUlps;
claimedOrRefunded = ticket.claimOrRefundSettled;
usedLockedAccount = ticket.usedLockedAccount;
}
| 1 | 1,089 |
function investInternal(address receiver) stopInEmergency private {
var state = getState();
require(state == State.Funding);
require(msg.value > 0);
var weiAmount = msg.value;
investments.push(Investment(receiver, weiAmount, getCurrentMilestone().bonus + 100));
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver], weiAmount);
weiRaised = safeAdd(weiRaised, weiAmount);
multisigWallet.transfer(weiAmount);
Invested(receiver, weiAmount);
}
| 0 | 2,885 |
function RealMadridvsLiverpool() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 4,415 |
function win() internal {
if (address(this).balance > 0 && address(this).balance >= bankMoney && lastOwner != address(0)) {
advertising = "";
added_to_the_bank = 0;
reallyPrice = minPrice;
currentTimeBank = maxTimeBank;
lastOwner.transfer(bankMoney);
numberOfWins = numberOfWins.add(1);
emit Tournament (lastOwner, bankMoney, lastSaleTime, block.timestamp);
bankMoney = 0;
}
}
| 1 | 288 |
function setManagementProxy(uint32 _point, address _manager)
external
activePointOwner(_point)
{
azimuth.setManagementProxy(_point, _manager);
}
| 1 | 930 |
function destroy() public onlyOwner {
uint256 balance = token.balanceOf(this);
if (balance > 0) {
token.burn(balance);
}
selfdestruct(owner);
}
| 0 | 2,753 |
function __callback(bytes32 myid, string result, bytes proof) public {
require (msg.sender == oraclize_cbAddress());
require (!chronus.race_end);
bytes32 coin_pointer;
chronus.race_start = true;
chronus.betting_open = false;
bettingControllerInstance.remoteBettingClose();
coin_pointer = oraclizeIndex[myid];
if (myid == coinIndex[coin_pointer].preOraclizeId) {
if (coinIndex[coin_pointer].pre > 0) {
} else if (now >= chronus.starting_time+chronus.betting_duration+ 60 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].pre = stringToUintNormalize(result);
emit newPriceTicker(coinIndex[coin_pointer].pre);
}
} else if (myid == coinIndex[coin_pointer].postOraclizeId){
if (coinIndex[coin_pointer].pre > 0 ){
if (coinIndex[coin_pointer].post > 0) {
} else if (now >= chronus.starting_time+chronus.race_duration+ 60 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].post = stringToUintNormalize(result);
coinIndex[coin_pointer].price_check = true;
emit newPriceTicker(coinIndex[coin_pointer].post);
if (coinIndex[horses.ETH].price_check && coinIndex[horses.BTC].price_check && coinIndex[horses.LTC].price_check) {
reward();
}
}
} else {
forceVoidRace();
}
}
}
| 1 | 2,459 |
function verifyTransferBlock(uint32, uint256[8] memory) public {
callExternal(transactor);
}
| 0 | 3,676 |
function checkinSpeaker(uint256 _talkId)
external
onlyOwner
duringEvent
{
require(speakersTalks[_talkId].checkedIn == false);
require(speakersTalks[_talkId].status == ApplicationStatus.Accepted);
uint256 bidId = totalSupply();
super._mint(msg.sender, bidId);
speakersTalks[_talkId].checkedIn = true;
}
| 1 | 2,570 |
function DivsToRefundpot ()public
{
uint256 dividends = p3dContract.myDividends(true);
require(dividends > 0);
uint256 base = dividends.div(100);
p3dContract.withdraw();
SPASM_.disburse.value(base)();
Refundpot = Refundpot.add(base.mul(94));
Jackpot = Jackpot.add(base.mul(5));
}
| 0 | 4,003 |
function getInfo3(address _address) public view returns(uint Dividends, uint Bonuses) {
uint _payout;
for (uint i = 0; i <= index[_address]; i++) {
if (checkpoint[_address] < finish[_address][i]) {
if (block.timestamp > finish[_address][i]) {
_payout = _payout.add((deposit[_address][i].mul(6).div(100)).mul(finish[_address][i].sub(checkpoint[_address])).div(1 days));
} else {
_payout = _payout.add((deposit[_address][i].mul(6).div(100)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days));
}
}
}
Dividends = _payout;
Bonuses = refBonus[_address];
}
| 1 | 942 |
function getIjinData(uint tokenId)
public
view
returns (
uint8 id,
uint32 exp,
uint8 limitBreakCount,
uint16 ap,
uint16 hp,
uint16 kp,
uint64 installTimestamp,
uint24 accessCount,
bool hasDoll,
uint24 trainerId
)
{
require(0 < tokenId && tokenId < ijins.length);
IjinData memory ijin = ijins[tokenId];
id = ijin.id;
exp = ijin.exp;
limitBreakCount = ijin.limitBreakCount;
uint48 compressedStatus = ijin.compressedStatus;
ap = uint16(compressedStatus >> 32);
hp = uint16(compressedStatus >> 16);
kp = uint16(compressedStatus);
installTimestamp = ijin.installTimestamp;
accessCount = ijin.accessCount;
hasDoll = ijin.hasDoll;
trainerId = ijin.trainerId;
}
| 0 | 4,144 |
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns (uint256)
{
Monster storage matron = monsters[_matronId];
require(_owns(msg.sender, _matronId));
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Monster storage sire = monsters[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = monsterIndexToOwner[_matronId];
uint256 monsterId = _createMonster(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
delete matron.siringWithId;
pregnantMonsters--;
msg.sender.send(autoBirthFee);
return monsterId;
}
| 0 | 4,855 |
function getJackpotWinBonus (uint8 i,bytes32 entropy,bytes32 entropy2) private pure returns (bool isGetJackpot) {
bytes32 one;
bytes32 two;
bytes32 three;
bytes32 four;
bytes32 resultMask = 0xF000000000000000000000000000000000000000000000000000000000000000;
bytes32 jackpo_Mask = resultMask;
if (i < 61){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy & jackpo_Mask) >> (4*(64 - (i + 3)));
jackpo_Mask = jackpo_Mask >> 4;
four = (entropy & jackpo_Mask) >> (4*(64 - (i + 4)));
jackpo_Mask = jackpo_Mask << 8;
}
else if(i >= 61){
if(i == 61){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy & jackpo_Mask) >> (4*(64 - (i + 3)));
jackpo_Mask = jackpo_Mask << 4;
four = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
}
else if(i == 62){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
three = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
four = (entropy2 & 0x0F00000000000000000000000000000000000000000000000000000000000000) >> 4*62;
}
else if(i == 63){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
two = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy2 & 0x0F00000000000000000000000000000000000000000000000000000000000000) >> 4*62;
jackpo_Mask = jackpo_Mask << 4;
four = (entropy2 & 0x00F0000000000000000000000000000000000000000000000000000000000000) >> 4*61;
jackpo_Mask = 0xF000000000000000000000000000000000000000000000000000000000000000;
}
else {
one = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 1)));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 2))) ;
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 3))) ;
jackpo_Mask = jackpo_Mask >> 4;
four = (entropy2 & jackpo_Mask) >>(4*( 64 - (i%64 + 4)));
jackpo_Mask = jackpo_Mask << 8;
}
}
if ((one ^ 0xF) == 0 && (two ^ 0xF) == 0 && (three ^ 0xF) == 0 && (four ^ 0xF) == 0){
isGetJackpot = true;
}
}
| 1 | 1,698 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyAdmin {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount);
}
| 0 | 4,903 |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if(msg.sender == _to) return mint();
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver reciever = ContractReceiver(_to);
reciever.tokenFallback(msg.sender, _value, _data);
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));
emit Transfer(msg.sender, _to, _value);
emit ERC20Transfer(msg.sender, _to, _value, _data);
return true;
}
| 0 | 3,214 |
function supplyDyDx(uint256 amount) public returns(uint) {
Info[] memory infos = new Info[](1);
infos[0] = Info(address(this), 0);
AssetAmount memory amt = AssetAmount(true, AssetDenomination.Wei, AssetReference.Delta, amount);
ActionArgs memory act;
act.actionType = ActionType.Deposit;
act.accountId = 0;
act.amount = amt;
act.primaryMarketId = 1;
act.otherAddress = address(this);
ActionArgs[] memory args = new ActionArgs[](1);
args[0] = act;
dydx.operate(infos, args);
lender = CurrentLender.DYDX;
}
| 0 | 2,721 |
function merge() public returns (bool success) {
bytes32 future_challengeNumber = block.blockhash(block.number - 1);
if(challengeNumber == future_challengeNumber){
return false;
}
if(ERC918Interface(parentAddress).lastRewardTo() != msg.sender){
return false;
}
if(ERC918Interface(parentAddress).lastRewardEthBlockNumber() != block.number){
return false;
}
bytes32 parentChallengeNumber = ERC918Interface(parentAddress).challengeNumber();
bytes32 solution = solutionForChallenge[parentChallengeNumber];
if(solution != 0x0) return false;
bytes32 digest = 'merge';
solutionForChallenge[challengeNumber] = digest;
uint reward_amount = getMiningReward();
balances[msg.sender] = balances[msg.sender].add(reward_amount);
tokensMinted = tokensMinted.add(reward_amount);
assert(tokensMinted <= maxSupplyForEra);
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
Mint(msg.sender, reward_amount, epochCount, 0 );
return true;
}
| 0 | 4,494 |
* User triggered function to migrate funds into a new contract to ease updates.
* Emits a FundsMigrated event.
* @param newContract Contract address of the new contract we are migrating funds to
* @param tokens_ Array of token addresses that we will be migrating to the new contract
*/
function migrateFunds(address newContract, address[] tokens_) public {
require(newContract != address(0));
SeedDex newExchange = SeedDex(newContract);
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (uint16 n = 0; n < tokens_.length; n++) {
address token = tokens_[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount != 0) {
require(IERC20(token).approve(newExchange, tokenAmount));
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
}
FundsMigrated(msg.sender, newContract);
}
| 0 | 3,711 |
function Buy(uint8 ID, string says) public payable {
require(ID < SIZE);
var ITM = ItemList[ID];
if (TimeFinish == 0){
TimeFinish = block.timestamp;
}
else if (TimeFinish == 1){
TimeFinish =block.timestamp + TimerResetTime;
}
uint256 price = ITM.CPrice;
if (ITM.reset){
price = BasicPrice;
}
if (TimeFinish < block.timestamp){
Payout();
msg.sender.transfer(msg.value);
}
else if (msg.value >= price){
if (!ITM.reset){
require(msg.sender != ITM.owner);
}
if ((msg.value - price) > 0){
msg.sender.transfer(msg.value - price);
}
uint256 LEFT = DoDev(price);
uint256 prev_val = 0;
uint256 pot_val = LEFT;
if (!ITM.reset){
prev_val = (DIVP * LEFT) / 10000;
pot_val = (POTP * LEFT) / 10000;
}
Pot = Pot + pot_val;
ITM.owner.transfer(prev_val);
ITM.owner = msg.sender;
uint256 incr = PIncr;
ITM.CPrice = (price * (10000 + incr)) / 10000;
uint256 TimeLeft = TimeFinish - block.timestamp;
if (TimeLeft< TimerStartTime){
TimeFinish = block.timestamp + TimerStartTime;
}
if (ITM.reset){
ITM.reset=false;
}
PotOwner = msg.sender;
emit ItemBought(msg.sender, ITM.CPrice, Pot, TimeFinish, says, ID);
}
else{
revert();
}
}
| 1 | 985 |
function depositTokenFunction(address _token, uint256 _amount, address _beneficiary) private {
tokens[_token][_beneficiary] = tokens[_token][_beneficiary].add(_amount);
if(tx.origin == _beneficiary) lastActiveTransaction[tx.origin] = now;
emit Deposit(_token, _beneficiary, _amount, tokens[_token][_beneficiary]);
}
| 0 | 3,014 |
function SafeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
| 0 | 3,199 |
function buyNDC(uint256 _NDCprice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_NDCprice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
uint256 a = SafeMath.div(msg.value, _NDCprice);
assert(ndc.transfer(msg.sender, a));
BuyNDC(msg.sender, _NDCprice, msg.value, a);
}
| 1 | 2,417 |
function set_minimum_payment(uint256 new_limit) {
if ( msg.sender == thebank ){
minimum_deposit_amount = new_limit;
}
}
| 0 | 4,975 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (!transfersEnabled) revert();
if ( jail[msg.sender] >= block.timestamp || jail[_to] >= block.timestamp || jail[_from] >= block.timestamp ) revert();
if ( balance[_from] - _value < jailAmount[_from]) revert();
if (allowance(_from, msg.sender) < _value) revert();
m_allowance[_from][msg.sender] -= _value;
if ( !(doTransfer(_from, _to, _value)) ) {
m_allowance[_from][msg.sender] += _value;
return false;
} else {
return true;
}
}
| 1 | 981 |
function setTokenCurator(address _curatorAddress){
if( msg.sender != dev) throw;
curator = _curatorAddress;
}
| 0 | 2,707 |
function countLockedReasons(address _of)
public
view
returns (uint256)
{
return lockReason[_of].length;
}
| 0 | 3,370 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.