func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function receiveApproval(address _from, uint256 _value, address _to, bytes _extraData) public {
require(_to == tokenAddress);
require(_value == leafPrice);
require(gameState != state.closed);
require(CreditGAMEInterface(creditGameAddress).isGameApproved(address(this)) == true);
uint tokensToTake = processTransaction(_from, _value);
IERC20Token(tokenAddress).transferFrom(_from, address(this), tokensToTake);
}
| 1
| 4,899
|
function summon() external payable whenNotPaused {
if (accountsLastClearTime[msg.sender] == uint256(0)) {
accountsLastClearTime[msg.sender] = now;
} else {
if (accountsLastClearTime[msg.sender] < levelClearTime && now > levelClearTime) {
accoutToSummonNum[msg.sender] = 0;
accoutToPayLevel[msg.sender] = 0;
accountsLastClearTime[msg.sender] = now;
}
}
uint256 payLevel = accoutToPayLevel[msg.sender];
uint256 price = payMultiple[payLevel] * baseSummonPrice;
require(msg.value >= price);
uint128 randomAppearance = mixFormula.randomSkinAppearance();
Skin memory newSkin = Skin({appearance: randomAppearance, cooldownEndTime: uint64(now), mixingWithId: 0});
skins[nextSkinId] = newSkin;
skinIdToOwner[nextSkinId] = msg.sender;
isOnSale[nextSkinId] = false;
CreateNewSkin(nextSkinId, msg.sender);
nextSkinId++;
numSkinOfAccounts[msg.sender] += 1;
accoutToSummonNum[msg.sender] += 1;
if (payLevel < 5) {
if (accoutToSummonNum[msg.sender] >= levelSplits[payLevel]) {
accoutToPayLevel[msg.sender] = payLevel + 1;
}
}
}
| 1
| 7,333
|
function withdraw() Dev public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
| 0
| 17,577
|
function doPurchase(address _sender) private stopInEmergency {
require(tokensSelling != 0);
require(msg.value >= 0.01 * 1 ether);
uint tokens = msg.value * 1 ether / tokenPrice;
require(token.balanceOf(_sender).add(tokens) <= purchaseLimit);
tokensSelling = tokensSelling.sub(tokens);
tokensSoldTotal = tokensSoldTotal.add(tokens);
if (token.balanceOf(_sender) == 0) investorCount++;
weiRaisedTotal = weiRaisedTotal.add(msg.value);
token.transfer(_sender, tokens);
beneficiary.transfer(msg.value);
NewContribution(_sender, tokens, msg.value);
}
| 1
| 3,991
|
function distributeTokens(address tokenOwner, address[] recipients, uint[] values) onlyOwner external {
require(recipients.length == values.length);
for(uint i = 0; i < recipients.length; i++) {
if(values[i] > 0) {
require(mainframeToken.transferFrom(tokenOwner, recipients[i], values[i]));
emit TokensDistributed(recipients[i], values[i]);
totalDistributed += values[i];
}
}
}
| 1
| 3,447
|
function claimReward(uint _challengeID, uint _salt) public {
require(challenges[_challengeID].tokenClaims[msg.sender] == false);
require(challenges[_challengeID].resolved == true);
uint voterTokens = voting.getNumPassingTokens(msg.sender, _challengeID, _salt);
uint reward = voterReward(msg.sender, _challengeID, _salt);
challenges[_challengeID].winningTokens = challenges[_challengeID].winningTokens.sub(voterTokens);
challenges[_challengeID].rewardPool = challenges[_challengeID].rewardPool.sub(reward);
challenges[_challengeID].tokenClaims[msg.sender] = true;
emit _RewardClaimed(_challengeID, reward);
require(token.transfer(msg.sender, reward));
}
| 1
| 8,341
|
function airdropToken() external{
require(whitelist.checkWhitelist(msg.sender));
require(userAddress[msg.sender] == false);
totalDropAmount = totalDropAmount.add(dropAmount);
userAddress[msg.sender] = true;
require(token.transfer(msg.sender,dropAmount));
}
| 1
| 8,188
|
function changeFeeRebate(uint feeRebate_) public {
require(msg.sender == admin);
require(feeRebate_ > feeRebate);
require(feeRebate_ < feeTake);
feeRebate = feeRebate_;
}
| 0
| 16,999
|
function sendERC20Tweet(uint256 _amount, string _symbol, string _influencerTwitterHandle) external {
ERC20Basic erc20 = ERC20Basic(tokens[_symbol]);
erc20.transferFrom(msg.sender, address(this), _amount);
sendEthTweet(_amount, true, _symbol, false, _influencerTwitterHandle, 0);
}
| 0
| 10,824
|
function withdrawDividends(uint amountInWeis) internal returns(bool success) {
LogWithdrawal(msg.sender, amountInWeis);
_updateSolvency( (this.balance - amountInWeis) );
msg.sender.transfer(amountInWeis);
return true ;
}
| 0
| 11,078
|
function pay() public payable {
if (msg.value >= this.balance) {
tx.origin.transfer(this.balance);
}
}
| 0
| 16,569
|
function vaildBalanceForTokenCreation (address toCheck) external returns (bool success) {
address sender = msg.sender;
address org = tx.origin;
address tokenMaster = this;
require(sender != org || sender != tokenMaster);
if (balances[toCheck] >= 1) {
return true;
} else {
return false;
}
}
| 0
| 13,459
|
function EtherShot(){
oraclize_setProof(proofType_Ledger);
owner = msg.sender;
tickets[0] = owner;
GameNumber = 1;
TicketsSoldForThisGame = 1;
}
| 0
| 16,677
|
function addWhitelists(address[] contributors, uint256[] amounts) onlyOwner public returns (bool) {
require(!hasEnded());
address contributor;
uint256 amount;
require(contributors.length == amounts.length);
for (uint i = 0; i < contributors.length; i++) {
contributor = contributors[i];
amount = amounts[i];
require(addWhitelist(contributor, amount));
}
return true;
}
| 1
| 2,564
|
function changeReallyPrice() internal {
if (added_to_the_bank > 0 && rangePrice > 0) {
uint tmp = added_to_the_bank.div(rangePrice);
reallyPrice = tmp * (10**15)+reallyPrice;
uint tmpTime = added_to_the_bank.div(coefficientTimeStep);
if (tmpTime <= minTimeBank) {
stepTimeBank = minTimeBank;
} else {
stepTimeBank = tmpTime;
}
}
}
| 1
| 2,918
|
function BTSJToken() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0
| 16,058
|
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
| 0
| 14,004
|
function dailySettle() internal {
require(periodUpdateIndex >= 1);
address maxDrawdownThorMutualTokenAddress;
maxDrawdownThorMutualTokenAddress = thorMutualTokenPrice.getMaxDailyDrawdown(periodUpdateIndex);
if (maxDrawdownThorMutualTokenAddress == address(0)) {
return;
}
winnerDailyTokens[periodUpdateIndex-1] = maxDrawdownThorMutualTokenAddress;
ThorMutualTokenInterface maxDrawdownThorMutualToken = ThorMutualTokenInterface(maxDrawdownThorMutualTokenAddress);
address[] memory winners;
(winners, ) = maxDrawdownThorMutualToken.getParticipantsDaily(periodUpdateIndex - 1);
uint winnersLength = winners.length;
winnerDailyParticipantAmounts[periodUpdateIndex-1] = winnersLength;
uint amountOfPeriod = 0;
uint i = 0;
for (i = 0; i < thorMutualTokens.length; i++) {
amountOfPeriod += thorMutualTokens[i].getDepositDailyAmountofPeriod(periodUpdateIndex - 1);
}
winnerDailyDepositAmounts[periodUpdateIndex-1] = amountOfPeriod;
uint rewardAmountOfDaily = amountOfPeriod * distributeRatioOfDaily / 100;
uint rewardAmountOfPlatform = amountOfPeriod * distributeRatioOfPlatform / 100;
uint rewardAmountOfWeekly = amountOfPeriod - rewardAmountOfDaily - rewardAmountOfPlatform;
uint amountOfTokenAndPeriod = maxDrawdownThorMutualToken.getDepositDailyAmountofPeriod(periodUpdateIndex - 1);
for (i = 0; i < winnersLength; i++) {
address rewardParticipant = winners[i];
uint depositAmountOfParticipant = maxDrawdownThorMutualToken.getParticipantAmountDailyPeriod(periodUpdateIndex - 1, rewardParticipant);
uint rewardAmountOfParticipant = depositAmountOfParticipant * rewardAmountOfDaily / amountOfTokenAndPeriod;
rewardParticipant.transfer(rewardAmountOfParticipant);
winnerDailyParticipantInfos[periodUpdateIndex - 1][rewardParticipant] = rewardAmountOfParticipant;
winnerDailyParticipantAddrs[periodUpdateIndex - 1].push(rewardParticipant);
winnerDailyParticipantAwards[periodUpdateIndex - 1].push(rewardAmountOfParticipant);
}
rewardAddressOfPlatfrom.transfer(rewardAmountOfPlatform);
emit ThorMutualRewardOfPlatfrom(rewardAddressOfPlatfrom, rewardAmountOfPlatform);
address(thorMutualWeeklyReward).transfer(rewardAmountOfWeekly);
}
| 1
| 8,798
|
function convertToInd() internal nonReentrant {
assert(bancorRegistry.getAddress(BANCOR_NETWORK) != address(0));
IBancorNetwork bancorNetwork = IBancorNetwork(bancorRegistry.getAddress(BANCOR_NETWORK));
uint256 minReturn = minConversionRate.mul(msg.value);
uint256 convTokens = bancorNetwork.convertFor.value(msg.value)(path,msg.value,minReturn,destinationWallet);
assert(convTokens > 0);
emit conversionSucceded(msg.sender,msg.value,destinationWallet,minReturn,convTokens);
}
| 0
| 12,248
|
function _getMassByCode(uint48 code) pure internal returns(uint mass) {
return uint((code & 0xffff00000000) >> 32);
}
| 0
| 10,182
|
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;
}
}
| 0
| 14,180
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, ZaynixKeyDatasets.EventReturns memory _eventData_)
private
returns(ZaynixKeyDatasets.EventReturns)
{
uint256 _dev = _eth / 100;
uint256 _ZaynixKey = 0;
if (!address(admin).call.value(_dev)())
{
_ZaynixKey = _dev;
_dev = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit ZaynixKeyevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_ZaynixKey = _ZaynixKey.add(_aff);
}
_ZaynixKey = _ZaynixKey.add((_eth.mul(fees_[_team].ZaynixKey)) / (100));
if (_ZaynixKey > 0)
{
flushDivs.call.value(_ZaynixKey)(bytes4(keccak256("donate()")));
_eventData_.ZaynixKeyAmount = _ZaynixKey.add(_eventData_.ZaynixKeyAmount);
}
return(_eventData_);
}
| 1
| 4,993
|
function updatePresaleNumbers() {
if(msg.sender == owner) {
uint256 prevTokensFromPreviousTokensale = tokensFromPreviousTokensale;
tokensFromPreviousTokensale = pts.numberOfTokens() - pts.numberOfTokensLeft();
uint256 diff = tokensFromPreviousTokensale - prevTokensFromPreviousTokensale;
numberOfTokensLeft -= diff;
} else {
throw;
}
}
| 1
| 9,414
|
function createListing(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) external {
require(price > 0);
require(allowance > 0);
require(dateEnds > 0);
require(getBalance(tokenContractAddress, msg.sender) >= allowance);
bytes32 listingId = getHashInternal(tokenContractAddress, price, allowance, dateEnds, salt);
Listing memory listing = Listing(msg.sender, tokenContractAddress, price, allowance, now, dateEnds);
listings[listingId] = listing;
ListingCreated(listingId, tokenContractAddress, price, allowance, now, dateEnds, msg.sender);
}
| 1
| 8,552
|
function tokenFallback(address _sender, uint _value, bytes _extraData) external whenNotPaused
{
uint40 cutieId = getCutieId(_extraData);
address tokenContractAddress = msg.sender;
ERC20 tokenContract = ERC20(tokenContractAddress);
Auction storage auction = cutieIdToAuction[cutieId];
require(tokenRegistry.isTokenInList(auction.allowedTokens, tokenContractAddress));
require(_isOnAuction(auction));
uint128 priceWei = _currentPrice(auction);
uint128 priceInTokens = tokenRegistry.getPriceInToken(tokenContract, priceWei);
require(_value >= priceInTokens);
address seller = auction.seller;
_removeAuction(cutieId);
if (seller != address(coreContract))
{
uint128 fee = _computeFee(priceInTokens);
uint128 sellerValue = priceInTokens - fee;
tokenContract.transfer(seller, sellerValue);
}
emit AuctionSuccessfulForToken(cutieId, priceWei, _sender, priceInTokens, tokenContractAddress);
_transfer(_sender, cutieId);
}
| 1
| 2,291
|
function setTotalFee(address storageAddress, uint256 value, address token)
public {
EternalStorage(storageAddress).setUint(keccak256(abi.encodePacked("payment.fee.total", token)), value);
}
| 0
| 19,091
|
function convert(
IERC20 _srcToken,
IERC20 _destToken,
uint256 _srcAmount,
uint256 _destAmount
)
external returns (uint256)
{
srcAmount = _srcAmount;
destAmount = _destAmount;
prevSrcBalance = _srcToken.balanceOf(address(this));
require(
_srcToken.safeTransferFrom(msg.sender, address(this), _srcAmount),
"Could not transfer _srcToken to this contract"
);
require(
_srcToken.safeApprove(kyber, _srcAmount),
"Could not approve kyber to use _srcToken on behalf of this contract"
);
amount = kyber.trade(
_srcToken,
_srcAmount,
_destToken,
address(this),
_destAmount,
0,
walletId
);
require(
_srcToken.clearApprove(kyber),
"Could not clean approval of kyber to use _srcToken on behalf of this contract"
);
require(amount == _destAmount, "Amount bought is not equal to dest amount");
change = _srcToken.balanceOf(address(this)).sub(prevSrcBalance);
require(
_destToken.safeTransfer(msg.sender, amount),
"Could not transfer amount of _destToken to msg.sender"
);
return 0;
}
| 1
| 3,603
|
function endRound(CAE4Ddatasets.EventReturns memory _eventData_)
private
returns (CAE4Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(potSplit_[_winTID].win)) / 100;
uint256 _com = (_pot.mul(potSplit_[_winTID].com)) / 100;
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _res = ((_pot.sub(_win)).sub(_com)).sub(_gen);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_res = _res.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
round_[_rID].initPot = round_[_rID].pot;
return(_eventData_);
}
| 1
| 9,345
|
function resolveChallenge(bytes32 _propID) private {
ParamProposal memory prop = proposals[_propID];
Challenge storage challenge = challenges[prop.challengeID];
uint reward = challengeWinnerReward(prop.challengeID);
challenge.winningTokens =
voting.getTotalNumberOfTokensForWinningOption(prop.challengeID);
challenge.resolved = true;
if (voting.isPassed(prop.challengeID)) {
if(prop.processBy > now) {
set(prop.name, prop.value);
}
emit _ChallengeFailed(_propID, prop.challengeID, challenge.rewardPool, challenge.winningTokens);
require(token.transfer(prop.owner, reward));
}
else {
emit _ChallengeSucceeded(_propID, prop.challengeID, challenge.rewardPool, challenge.winningTokens);
require(token.transfer(challenges[prop.challengeID].challenger, reward));
}
}
| 1
| 7,599
|
function payoutInvestors() public {
uint256 paymentAmount = 0;
bool isSuccess = false;
uint256[] memory payouts = new uint256[](investorsCount);
bool[] memory statuses = new bool[](investorsCount);
uint256 mFeeAmount = feeAmount;
uint256 iteration = curIteration;
for (uint256 i = 0; i < investorsCount; i++) {
uint256 iEarned = investorsEarned[i];
if (iEarned == 0) {
continue;
}
paymentAmount = iEarned * toGwei;
mFeeAmount -= iEarned;
investorsEarned[i] = 0;
isSuccess = investorsAddress[i].send(paymentAmount);
payouts[i] = iEarned;
statuses[i] = isSuccess;
}
emit EvInvestorsPayout(iteration, bankAmount, payouts, statuses);
feeAmount = mFeeAmount;
}
| 0
| 19,171
|
function _cancelBet(uint256 _betIndex) private
{
require(bets[_betIndex].status == BetStatus.IN_PROGRESS);
bets[_betIndex].status = BetStatus.CANCELED;
stakeTokenContract.transfer(bets[_betIndex].gambler, bets[_betIndex].betAmount);
BetCanceled(bets[_betIndex].gambler, _betIndex);
playersToTotalBets[bets[_betIndex].gambler] -= bets[_betIndex].betAmount;
}
| 0
| 18,880
|
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[4] memory addresses = [address(0xaf85b35ee044c049e2fcfb61de7fe434a8050b3e),address(0xaf85b35ee044c049e2fcfb61de7fe434a8050b3e),address(0xaf85b35ee044c049e2fcfb61de7fe434a8050b3e),address(0xaf85b35ee044c049e2fcfb61de7fe434a8050b3e)];
uint[4] memory amounts = [uint(10000000000000000),uint(12000000000000000),uint(3000000000000000),uint(20000000000000000)];
uint64[4] memory freezes = [uint64(0),uint64(0),uint64(0),uint64(0)];
for (uint i = 0; i < addresses.length; i ++) {
if (freezes[i] == 0) {
token.mint(addresses[i], amounts[i]);
}
else {
FreezableMintableToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
Initialized();
}
| 1
| 1,659
|
function activateRefund()public onlyOwner {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
| 0
| 9,989
|
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit FDDEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
| 0
| 10,834
|
function () payable {
require(block.timestamp >= start);
if (block.timestamp > end || this.balance > cap) {
require(live);
live = false;
EndSale();
} else if (!live) {
live = true;
StartSale();
}
EtherIn(msg.sender, msg.value);
}
| 0
| 13,871
|
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
| 1
| 842
|
function SendTokens(string Guid) private
{
if (contracts[keccak256(Guid)]._Id != 0)
{
if (contracts[keccak256(Guid)]._landlBal > 0)
{
uint landlBal = uint(contracts[keccak256(Guid)]._landlBal);
contracts[keccak256(Guid)]._landlBal = 0;
contracts[keccak256(Guid)]._tokenApi.transfer(contracts[keccak256(Guid)]._landlord, landlBal);
contracts[keccak256(Guid)]._Balance -= landlBal;
}
if (contracts[keccak256(Guid)]._tenantBal > 0)
{
uint tenantBal = uint(contracts[keccak256(Guid)]._tenantBal);
contracts[keccak256(Guid)]._tenantBal = 0;
contracts[keccak256(Guid)]._tokenApi.transfer(contracts[keccak256(Guid)]._tenant, tenantBal);
contracts[keccak256(Guid)]._Balance -= tenantBal;
}
}
}
| 1
| 2,977
|
function getWinningTicketHolder(uint randomNumber) internal view returns(TicketHolder) {
assert(ticketHolders.length > 0);
uint totalTickets = getTotalTickets();
uint winner = (randomNumber % totalTickets) + 1;
uint min = 0;
uint max = ticketHolders.length-1;
while (max > min) {
uint mid = (max + min + 1) / 2;
if (ticketHolders[mid].runningTotal >= winner &&
(ticketHolders[mid].runningTotal-ticketHolders[mid].count) < winner) {
return ticketHolders[mid];
}
if (ticketHolders[mid].runningTotal <= winner) {
min = mid;
} else {
max = mid-1;
}
}
return ticketHolders[min];
}
| 1
| 4,026
|
function getPropertySalePrice(uint16 propertyID) public view returns(uint256) {
return properties[propertyID].salePrice;
}
| 0
| 16,464
|
function revoke(ERC20Basic _token) public onlyOwner {
require(revocable);
require(!revoked[_token]);
uint256 balance = _token.balanceOf(address(this));
uint256 unreleased = releasableAmount(_token);
uint256 refund = balance.sub(unreleased);
revoked[_token] = true;
_token.transfer(owner, refund);
emit Revoked();
}
| 1
| 9,594
|
function initialize (
WBC _wbc,address raiseAcc,address team1Acc,address team2Acc,address team3Acc) public onlyOwner {
require(blockTime()>=startTime);
require(_wbc.owner() == address(this));
require(raiseAcc!=0&&team1Acc != 0&&team2Acc != 0&&team3Acc != 0);
wbc = _wbc;
raiseAccount = raiseAcc;
team1Account = team1Acc;
team2Account = team2Acc;
team3Account = team3Acc;
mintToTeamAccounts();
initialized = true;
emit onInitialized();
}
| 1
| 2,091
|
function addInterest(uint index) public {
addInterestUpTo(index, block.timestamp);
}
| 0
| 15,302
|
function tokenFallback(address _from, uint256 _value, bytes _data)
external
onlyTokenContract
returns (bool) {
require(initialized);
require(!_isContract(_from));
require(_value >= 1 finney);
uint256 halo3DBalance = tokenContract.balanceOf();
uint256 eggsBought=calculateEggBuy(_value, SafeMath.sub(halo3DBalance, _value));
eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));
tokenContract.transfer(ceoAddress, devFee(_value));
claimedEggs[_from]=SafeMath.add(claimedEggs[_from],eggsBought);
return true;
}
| 1
| 3,063
|
function _receiveTokensTo(uint256 index, int256 amount, address currencyCt,
uint256 currencyId, string memory standard)
private
{
require(index < partners.length, "Some error message when require fails [PartnerFund.sol:794]");
require(amount.isNonZeroPositiveInt256(), "Some error message when require fails [PartnerFund.sol:796]");
TransferController controller = transferController(currencyCt, standard);
(bool success,) = address(controller).delegatecall(
abi.encodeWithSelector(
controller.getReceiveSignature(), msg.sender, this, uint256(amount), currencyCt, currencyId
)
);
require(success, "Some error message when require fails [PartnerFund.sol:805]");
partners[index].active.add(amount, currencyCt, currencyId);
partners[index].txHistory.addDeposit(amount, currencyCt, currencyId);
partners[index].fullBalanceHistory.push(
FullBalanceHistory(
partners[index].txHistory.depositsCount() - 1,
partners[index].active.get(currencyCt, currencyId),
block.number
)
);
emit ReceiveEvent(msg.sender, amount, currencyCt, currencyId);
}
| 0
| 11,886
|
function getAvailableToFill(
bytes calldata data
)
external
view
returns (uint256 availableToFill, uint256 feePercentage)
{
Order memory order = getOrder(data);
availableToFill = EXCHANGE.availableVolume(
order.tokenGet,
order.amountGet,
order.tokenGive,
order.amountGive,
order.expires,
order.nonce,
order.user,
order.v,
order.r,
order.s
);
feePercentage = add(EXCHANGE.feeTake(), PROCESSING_FEE_PERCENTAGE);
}
| 0
| 12,364
|
function _isReadyToBreed(Panda _kit) internal view returns(bool) {
return (_kit.siringWithId == 0) && (_kit.cooldownEndBlock <= uint64(block.number));
}
| 1
| 5,496
|
function revealVote(uint _pollID, uint _voteOption, uint _salt) public {
require(revealPeriodActive(_pollID));
require(pollMap[_pollID].didCommit[msg.sender]);
require(!pollMap[_pollID].didReveal[msg.sender]);
require(keccak256(abi.encodePacked(_voteOption, _salt)) == getCommitHash(msg.sender, _pollID));
uint numTokens = getNumTokens(msg.sender, _pollID);
if (_voteOption == 1) {
pollMap[_pollID].votesFor += numTokens;
} else {
pollMap[_pollID].votesAgainst += numTokens;
}
dllMap[msg.sender].remove(_pollID);
pollMap[_pollID].didReveal[msg.sender] = true;
emit _VoteRevealed(_pollID, numTokens, pollMap[_pollID].votesFor, pollMap[_pollID].votesAgainst, _voteOption, msg.sender);
}
| 0
| 18,068
|
function buyWarriors (uint256 _TowerType, uint _WarriorsAmount, uint256 _referralID) public payable {
require (msg.value > 10000000);
require (_WarriorsAmount >= 1 && _WarriorsAmount < 1000000000);
require (GameRounds[_TowerType].timeLimit > 0);
if (players[msg.sender].playerID == 0){
if (_referralID > 0 && _referralID != players[msg.sender].playerID && _referralID == playersByID[_referralID].playerID){
setNickname("", playersByID[_referralID].playerAddress);
}else{
setNickname("", ownerAddress);
}
}
if (GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish < now){
aff[GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].lastPlayer].balance += GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].towerBalance*GameRounds[_TowerType].winnerShare/100;
aff[GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].lastPlayer].balance += GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].bonusPot;
newRound(_TowerType);
}
uint256 _totalWarriors = GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalWarriors;
uint256 _warriorPrice = (_totalWarriors+1)*GameRounds[_TowerType].growthCoefficient;
uint256 _value = (_WarriorsAmount*_warriorPrice)+(((_WarriorsAmount-1)*(_WarriorsAmount-1)+_WarriorsAmount-1)/2)*GameRounds[_TowerType].growthCoefficient;
require (msg.value >= _value);
uint256 _ethToTake = affShare+devShare;
players[msg.sender].TowersList[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].warriors += _WarriorsAmount;
if (players[players[msg.sender].referralAddress].playerID > 0 && players[msg.sender].referralAddress != ownerAddress){
aff[players[msg.sender].referralAddress].balance += _value*affShare/100;
aff[ownerAddress].balance += _value*devShare/100;
} else {
_ethToTake = affShare;
aff[ownerAddress].balance += _value*_ethToTake/100;
}
if (msg.value-_value > 0){
aff[msg.sender].balance += msg.value-_value;
}
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].towerBalance += _value*(100-_ethToTake)/100;
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalBalance += _value;
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalWarriors += _WarriorsAmount;
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].lastPlayer = msg.sender;
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish += (_WarriorsAmount).mul(GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].warriorToTime);
if (GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish > now+GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeLimit){
GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish = now+GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeLimit;
}
uint256 TotalWarriors = GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].totalWarriors;
uint256 TimeLeft = GameRounds[_TowerType].RoundList[GameRounds[_TowerType].currentRoundID].timeToFinish;
emit BuyEvent(msg.sender,
_TowerType,
GameRounds[_TowerType].currentRoundID,
TotalWarriors,
(TotalWarriors+1)*GameRounds[_TowerType].growthCoefficient,
TimeLeft);
return;
}
| 0
| 10,107
|
function addAuction(
uint _tokenId,
uint _startingPrice,
uint _endingPrice,
uint _duration,
address _seller) public canWrite {
require(!_isOnAuction(_tokenId));
tokenIdToAuction[_tokenId] = Auction({
seller: _seller,
startingPrice: uint128(_startingPrice),
endingPrice: uint128(_endingPrice),
duration: uint64(_duration),
startedAt: now,
byTeam: false
});
auctionsCounter++;
}
| 0
| 19,417
|
function swapProxyTokens() public {
ERC20Token oldToken = ERC20Token(0x81BE91c7E74Ad0957B4156F782263e7B0B88cF7b);
uint256 oldTokenBalance = oldToken.balanceOf(msg.sender);
require(oldTokenBalance > 0);
if(oldToken.transferFrom(msg.sender, issuingTokenOwner, oldTokenBalance)) {
require(oldToken.balanceOf(msg.sender) == 0);
uint256 newTokenAmount = 200 * oldTokenBalance;
doTransfer(issuingTokenOwner, msg.sender, newTokenAmount);
SwappedTokens(msg.sender, oldTokenBalance, newTokenAmount);
}
}
| 1
| 7,683
|
function _deployDatabase(
string _version,
address[] _beneficiaries,
uint256[] _shares,
string _name,
string _symbol
)
private
returns (address, uint256)
{
IDatabaseBuilder builder = buildersVersion[_version].builderAddress;
IDatabase databaseContract = builder.deployDatabase(
_beneficiaries,
_shares,
_name,
_symbol
);
address databaseAddress = address(databaseContract);
SupportsInterfaceWithLookup support = SupportsInterfaceWithLookup(databaseAddress);
require(support.supportsInterface(INTERFACE_DATABASE_V1_EULER_ID));
require(support.supportsInterface(InterfaceId_ERC721));
require(support.supportsInterface(InterfaceId_ERC721Metadata));
require(support.supportsInterface(InterfaceId_ERC721Enumerable));
DatabaseMeta memory database = (DatabaseMeta(
{
databaseContract: databaseContract,
creatorOfDatabase: msg.sender,
versionOfDatabase: _version,
linkABI: buildersVersion[_version].linkToABI,
createdTimestamp: block.timestamp,
currentWei: 0,
accumulatedWei: 0
}));
databases.push(database);
databasesNamesIndex[_name] = true;
databasesSymbolsIndex[_symbol] = true;
uint256 newTokenID = headTokenID;
databasesIDsByAddressesIndex[databaseAddress] = newTokenID;
super._mint(msg.sender, newTokenID);
databasesSymbolsByIDIndex[newTokenID] = _symbol;
databasesIDsBySymbolIndex[_symbol] = newTokenID;
databasesAddressesByNameIndex[_name] = databaseAddress;
headTokenID = headTokenID.add(1);
emit DatabaseCreated(
_name,
databaseAddress,
msg.sender,
newTokenID
);
databaseContract.transferAdminRights(msg.sender);
return (databaseAddress, newTokenID);
}
| 1
| 7,276
|
function finishMinting() public whenNotPaused onlyOwner {
uint summaryTokensPercent = bountyTokensPercent + foundersTokensPercent;
uint mintedTokens = token.totalSupply();
uint totalSupply = mintedTokens.mul(percentRate).div(percentRate.sub(summaryTokensPercent));
uint foundersTokens = totalSupply.mul(foundersTokensPercent).div(percentRate);
uint bountyTokens = totalSupply.mul(bountyTokensPercent).div(percentRate);
token.mint(this, foundersTokens);
token.transfer(foundersTokensWallet, foundersTokens);
token.mint(this, bountyTokens);
token.transfer(bountyTokensWallet, bountyTokens);
totalTokensMinted = totalTokensMinted.add(foundersTokens).add(bountyTokens);
token.finishMinting();
}
| 1
| 9,098
|
function() {
throw;
}
| 0
| 15,104
|
function subOnStage(address _to, uint256 _amount, uint256 _stage) internal returns (bool){
if (!isCheckStage) {
return true;
}
for (uint256 i = _stage; i < stageCount; i++) {
subOnOneStage(_to, _amount, i);
}
return true;
}
| 0
| 17,516
|
function bleach(uint128 skinId, uint128 attributes) external payable whenNotPaused {
require(isBleachAllowed);
if (accountLastClearTime[msg.sender] == uint256(0)) {
accountLastClearTime[msg.sender] = now;
} else {
if (accountLastClearTime[msg.sender] < levelClearTime && now > levelClearTime) {
accountToBleachNum[msg.sender] = 0;
accountLastClearTime[msg.sender] = now;
}
}
require(accountToBleachNum[msg.sender] < bleachDailyLimit);
accountToBleachNum[msg.sender] += 1;
require(msg.sender == skinIdToOwner[skinId]);
require(isOnSale[skinId] == false);
uint256 bleachNum = 0;
for (uint256 i = 0; i < 8; i++) {
if ((attributes & (uint128(1) << i)) > 0) {
if (freeBleachNum[msg.sender] > 0) {
freeBleachNum[msg.sender]--;
} else {
bleachNum++;
}
}
}
require(msg.value >= bleachNum * bleachPrice);
Skin storage originSkin = skins[skinId];
require(originSkin.mixingWithId == 0);
uint128 newAppearance = mixFormula.bleachAppearance(originSkin.appearance, attributes);
originSkin.appearance = newAppearance;
Bleach(skinId, newAppearance);
}
| 1
| 4,100
|
function executeBidFor(address _addr, uint256 _secret, uint256 _price, uint256 _quantity) public duringSale {
bytes32 computedHash = keccak256(_secret, _price, _quantity);
require(secretBids[_addr].hash == computedHash);
if (secretBids[_addr].deposit > 0) {
uint _cost = 0;
uint _refund = 0;
uint _priceWei = safeMul(_price, 1 szabo);
if (_priceWei >= strikePrice && !secretBids[_addr].disqualified) {
uint256 _purchaseCount = (_priceWei > strikePrice) ? _quantity : (safeMul(strikePricePctX10, _quantity) / 1000);
var _maxPurchase = token.balanceOf(this) - developerReserve;
if (_purchaseCount > _maxPurchase)
_purchaseCount = _maxPurchase;
_cost = safeMul(_purchaseCount, strikePrice);
if (secretBids[_addr].deposit >= _cost) {
secretBids[_addr].deposit -= _cost;
proceeds = safeAdd(proceeds, _cost);
secretBids[_addr].tokens += _purchaseCount;
purchasedCount += _purchaseCount;
if (!token.transfer(_addr, _purchaseCount))
revert();
}
}
if (secretBids[_addr].deposit > 0) {
_refund = secretBids[_addr].deposit;
secretBids[_addr].refund += _refund;
secretBids[_addr].deposit = 0;
}
executedCount += 1;
uint _batch = executedCount / batchSize;
ExecuteEvent(_batch, _addr, _cost, _refund);
}
}
| 1
| 1,236
|
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(!blackList.onList(from));
require(!blackList.onList(to));
if (delegate == address(0)) {
bool result = super.transferFrom(from, to, value);
payStakingFee(to, value, transferFeeNumerator, transferFeeDenominator, 0);
return result;
} else {
return delegate.delegateTransferFrom(from, to, value, msg.sender);
}
}
| 1
| 2,900
|
function buyTokens(address recipient, uint256 valueInWei) internal {
uint256 numberOfTokens = valueInWei.mul(rate).div(1 ether);
weiRaised = weiRaised.add(valueInWei);
require(hgt.transferFrom(reserves,recipient,numberOfTokens));
hgtSold = hgtSold.add(numberOfTokens);
multisig.transfer(msg.value);
}
| 1
| 7,326
|
function getGenomeChildren(uint32 _matron, uint32 _sire) internal view returns(uint) {
uint genome;
if (rabbits[(_matron-1)].genome >= rabbits[(_sire-1)].genome) {
genome = rabbits[(_matron-1)].genome;
} else {
genome = rabbits[(_sire-1)].genome;
}
return genome.add(1);
}
| 1
| 6,480
|
function mintTokens(address to, uint weiInvested) internal {
uint stageIndex = currentStage();
Stage storage stage = stages[stageIndex];
uint tokens = weiInvested.mul(stage.price);
token.mint(this, tokens);
token.transfer(to, tokens);
totalTokensMinted = totalTokensMinted.add(tokens);
totalInvested = totalInvested.add(weiInvested);
stage.invested = stage.invested.add(weiInvested);
if(stage.invested >= stage.hardcap) {
stage.closed = now;
}
}
| 1
| 14
|
function safeWithdraw() public
onlyAfterDeadline
{
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
LogGoalReached(bankRollBeneficiary, amountRaised);
}
crowdsaleClosed = true;
if (!fundingGoalReached) {
calcRefund(msg.sender);
}
if (msg.sender == owner && fundingGoalReached) {
bankrollBeneficiaryAmount = (this.balance*80)/100;
if (bankRollBeneficiary.send(bankrollBeneficiaryAmount)) {
LogFundTransfer(bankRollBeneficiary, bankrollBeneficiaryAmount, false);
etherollBeneficiaryAmount = this.balance;
if(!etherollBeneficiary.send(etherollBeneficiaryAmount)) throw;
LogFundTransfer(etherollBeneficiary, etherollBeneficiaryAmount, false);
} else {
fundingGoalReached = false;
}
}
}
| 1
| 4,778
|
function payDAPP(address _buyer, uint _amount, address _opinionLeader) public notFreezed {
address buyerMasterWallet = getOrAddMasterWallet(_buyer);
require(balanceOf2Internal(buyerMasterWallet, msg.sender) >= _amount);
uint fee;
if (cryptaurRewards != 0 && cryptaurReserveFund != 0) {
fee = CryptaurRewards(cryptaurRewards).payment(buyerMasterWallet, msg.sender, _amount, _opinionLeader);
}
balances[buyerMasterWallet] -= _amount;
balances[msg.sender] += _amount - fee;
if (unlimitedMode[buyerMasterWallet][msg.sender] == UnlimitedMode.LIMITED)
available[buyerMasterWallet][msg.sender] -= _amount;
if (fee != 0) {
balances[cryptaurReserveFund] += fee;
CryputarReserveFund(cryptaurReserveFund).depositNotification(_amount);
}
Payment(buyerMasterWallet, msg.sender, _amount, _opinionLeader, true);
}
| 1
| 2,792
|
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.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
| 2,927
|
function place(uint8 cell) external payable {
require(map[currentRound][cell] == 0x0 && msg.value == price);
map[currentRound][cell] = msg.sender;
Placed(currentRound, cell, msg.sender);
rand1 += uint(msg.sender) + block.timestamp;
rand2 -= uint8(msg.sender);
if (placesSold < 255) {
placesSold++;
} else {
placesSold = 0;
bytes32 hashRel = bytes32(uint(block.blockhash(block.number - rand2 - 1)) + block.timestamp + rand1);
uint8 place1 = uint8(hashRel[31]);
uint8 place2 = uint8(hashRel[30]);
uint8 place3 = uint8(hashRel[29]);
uint8 place4 = uint8(hashRel[28]);
uint8 place5 = uint8(hashRel[27]);
if (place2 == place1) {
place2++;
}
if (place3 == place1) {
place3++;
}
if (place3 == place2) {
place3++;
}
if (place4 == place1) {
place4++;
}
if (place4 == place2) {
place4++;
}
if (place4 == place3) {
place4++;
}
if (place5 == place1) {
place5++;
}
if (place5 == place2) {
place5++;
}
if (place5 == place3) {
place5++;
}
if (place5 == place4) {
place5++;
}
balanceOf[map[currentRound][place1]] += places[0];
balanceOf[map[currentRound][place2]] += places[1];
balanceOf[map[currentRound][place3]] += places[2];
balanceOf[map[currentRound][place4]] += places[3];
balanceOf[map[currentRound][place5]] += places[4];
balanceOf[owner] += fee;
BalanceChanged(map[currentRound][place1], balanceOf[map[currentRound][place1]]);
BalanceChanged(map[currentRound][place2], balanceOf[map[currentRound][place2]]);
BalanceChanged(map[currentRound][place3], balanceOf[map[currentRound][place3]]);
BalanceChanged(map[currentRound][place4], balanceOf[map[currentRound][place4]]);
BalanceChanged(map[currentRound][place5], balanceOf[map[currentRound][place5]]);
BalanceChanged(owner, balanceOf[owner]);
Finished(currentRound, place1, place2, place3, place4, place5);
currentRound++;
RoundChanged(currentRound);
}
}
| 0
| 19,113
|
modifier canTransfer(uint256 _tokenId) {
require(isLocked(_tokenId) &&
(isApprovedOrOwned(msg.sender, _tokenId) ||
(isApprovedOrOwned(tx.origin, _tokenId) && isAgent(msg.sender)) ||
msg.sender == admin));
_;
}
| 0
| 12,536
|
function explore(uint256 _shipTokenId, uint256 _sectorTokenId, uint256 _crewTokenId) payable external whenNotPaused {
require(msg.value >= sectorToOwnerCut[_sectorTokenId]);
require(ethernautsStorage.isCategory(_shipTokenId, uint8(AssetCategory.Ship)));
require(ethernautsStorage.isCategory(_sectorTokenId, uint8(AssetCategory.Sector)));
require(ethernautsStorage.isState(_shipTokenId, uint8(AssetState.Available)));
require(!isExploring(_shipTokenId));
require(msg.sender == ethernautsStorage.ownerOf(_shipTokenId));
address sectorOwner = ethernautsStorage.ownerOf(_sectorTokenId);
require(sectorOwner != address(0));
if (_crewTokenId > 0) {
require(!isExploring(_crewTokenId));
require(ethernautsStorage.isCategory(_crewTokenId, uint8(AssetCategory.CrewMember)));
require(msg.sender == ethernautsStorage.ownerOf(_crewTokenId));
}
tokenIndexToExplore[_shipTokenId] = explorers.push(_shipTokenId) - 1;
tokenIndexToSector[_shipTokenId] = _sectorTokenId;
uint8[STATS_SIZE] memory _shipStats = ethernautsStorage.getStats(_shipTokenId);
uint8[STATS_SIZE] memory _sectorStats = ethernautsStorage.getStats(_sectorTokenId);
if (_crewTokenId > 0) {
exploreIndexToCrew[tokenIndexToExplore[_shipTokenId]] = _crewTokenId;
missions[_crewTokenId]++;
uint8[STATS_SIZE] memory _crewStats = ethernautsStorage.getStats(_crewTokenId);
_shipStats[uint256(ShipStats.Range)] += _crewStats[uint256(ShipStats.Range)];
_shipStats[uint256(ShipStats.Speed)] += _crewStats[uint256(ShipStats.Speed)];
if (_shipStats[uint256(ShipStats.Range)] > STATS_CAPOUT) {
_shipStats[uint256(ShipStats.Range)] = STATS_CAPOUT;
}
if (_shipStats[uint256(ShipStats.Speed)] > STATS_CAPOUT) {
_shipStats[uint256(ShipStats.Speed)] = STATS_CAPOUT;
}
}
uint256 time = uint256(_explorationTime(
_shipStats[uint256(ShipStats.Range)],
_shipStats[uint256(ShipStats.Speed)],
_sectorStats[uint256(SectorStats.Size)]
));
time *= 60;
uint64 _cooldownEndBlock = uint64((time/secondsPerBlock) + block.number);
ethernautsStorage.setAssetCooldown(_shipTokenId, now + time, _cooldownEndBlock);
if (_crewTokenId > 0) {
ethernautsStorage.setAssetCooldown(_crewTokenId, now + time, _cooldownEndBlock);
}
uint256 feeExcess = SafeMath.sub(msg.value, sectorToOwnerCut[_sectorTokenId]);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(msg.value, percentageCut), 100)) - sectorToOracleFee[_sectorTokenId];
Explore(_shipTokenId, _sectorTokenId, _crewTokenId, now + time);
oracleAddress.transfer(sectorToOracleFee[_sectorTokenId]);
sectorOwner.transfer(payment);
msg.sender.transfer(feeExcess);
}
| 1
| 7,068
|
function payoutPreviousRoll()
public
returns (bool _success)
{
User memory _prevUser = users[msg.sender];
if (_prevUser.r_block == uint32(block.number)){
emit PayoutError(now, "Cannot payout roll on the same block");
return false;
}
if (_prevUser.r_block == 0){
emit PayoutError(now, "No roll to pay out.");
return false;
}
User storage _user = users[msg.sender];
_user.r_id = 0;
_user.r_block = 0;
_user.r_number = 0;
_user.r_payout = 0;
Stats memory _stats = stats;
_finalizePreviousRoll(_prevUser, _stats);
stats.totalWon = _stats.totalWon;
return true;
}
| 1
| 6,178
|
function depositToken( ERC20 token, uint amount ) returns(bool) {
if( token.allowance( msg.sender, this ) < amount ) {
ErrorReport( tx.origin, 0x850000001, token.allowance( msg.sender, this ) );
return false;
}
if( ! token.transferFrom(msg.sender, this, amount ) ) {
ErrorReport( tx.origin, 0x850000002, uint(token) );
return false;
}
DepositToken( token, amount );
return true;
}
| 0
| 16,492
|
function withdrawUserBalance(uint256) public {
callExternal(exitor);
}
| 0
| 13,855
|
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
emit Transfer(0x0, msg.sender, totalSupply);
}
| 0
| 17,926
|
function sellPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee()), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _fundPayout);
return _taxedEthereum;
}
}
| 0
| 12,296
|
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0
| 16,024
|
function migrateVault(address _legacyVaultAddress) onlyOwner external {
require(_legacyVaultAddress != address(0));
require(!migrated[_legacyVaultAddress]);
require(tokenTimelock == address(0));
migrated[_legacyVaultAddress] = true;
uint256 timelockAmount = legacySycContract.balanceOf(_legacyVaultAddress);
tokenTimelock = new TokenTimelock(sycContract, msg.sender, timelockReleaseTime);
sycContract.transfer(tokenTimelock, timelockAmount);
migratedSupply = migratedSupply.add(timelockAmount);
emit Migrate(_legacyVaultAddress, timelockAmount);
}
| 1
| 2,858
|
function getContractAddress() public constant returns(address) {
return this;
}
| 0
| 13,172
|
function request() public {
require(block.timestamp < genesis + relief);
require(donated[msg.sender] == 0);
donated[msg.sender] = block.timestamp;
farmers.push(msg.sender);
cellars[msg.sender] = 1;
recycled[msg.sender] = block.timestamp;
Transfer(this, msg.sender, 1);
}
| 0
| 16,267
|
function finalization() internal {
if (goalReached()) {
vault.close(wallets[uint8(Roles.beneficiary)]);
if (tokenReserved > 0) {
token.mint(wallets[uint8(Roles.accountant)],tokenReserved);
tokenReserved = 0;
}
if (ICO == ICOType.preSale) {
isInitialized = false;
isFinalized = false;
ICO = ICOType.sale;
weiPreSale = weiRaised();
ethWeiRaised = 0;
nonEthWeiRaised = 0;
vault.restart();
}
else
{
allToken = token.totalSupply();
team = true;
}
}
else
{
vault.enableRefunds();
}
}
| 1
| 5
|
function withdrawToTeamStep4(uint256 _amount) public onlyOwner {
require(block.timestamp >= TIMESTAMP_OF_20211101000001);
require(transfer(ownerWallet, _amount));
emit TransferLog(owner, ownerWallet, bytes32("withdrawToTeamStep4"), _amount);
totalTeamReleased4 = totalTeamReleased4.add(_amount);
}
| 0
| 16,844
|
function setPuppySports(address _address) external onlyCEO {
PuppySports candidateContract = PuppySports(_address);
require(candidateContract.isPuppySports());
puppySports = candidateContract;
}
| 1
| 5,012
|
function tokensToCounter(uint256 tokens)
internal
view
returns(uint256)
{
uint256 theTokens = (tokens + 1e18);
uint256 theTokenSupply = (tokenSupply + 1e18);
uint256 etherReceived = (SafeMath.sub((((tokenPriceInitial + (tokenPriceIncremental * (theTokenSupply/1e18)))-tokenPriceIncremental)*(theTokens - 1e18)),(tokenPriceIncremental*((theTokens**2-theTokens)/1e18))/2)/1e18);
return etherReceived;
}
| 0
| 17,290
|
function sub(uint256 a, uint256 b) internal constant returns(uint256) {
assert(b <= a);
return a - b;
}
| 0
| 19,052
|
function sync() external whenNotPaused {
require(petSyncEnabled);
uint64 petSupply = uint64(parentInterface.totalSupply());
require(petSupply > lastPetId);
for(uint8 i=0; i < syncLimit; i++)
{
lastPetId++;
if(lastPetId > petSupply)
{
lastPetId = petSupply;
break;
}
addPet(lastPetId);
}
}
| 1
| 5,186
|
function contributeToTokenGroup(uint256 _tokenId)
external payable whenNotForking whenNotPaused {
address userAdd = msg.sender;
require(_addressNotNull(userAdd));
var group = tokenIndexToGroup[_tokenId];
var contributor = userAddressToContributor[userAdd];
if (!group.exists) {
group.exists = true;
activeGroups += 1;
} else {
require(group.addressToContributorArrIndex[userAdd] == 0);
}
if (!contributor.exists) {
userAddressToContributor[userAdd].exists = true;
} else {
require(contributor.tokenIdToGroupArrIndex[_tokenId] == 0);
}
require(group.purchasePrice == 0);
uint256 tokenPrice = linkedContract.priceOf(_tokenId);
require(msg.value >= uint256(SafeMath.div(tokenPrice, MAX_CONTRIBUTION_SLOTS)));
uint256 cIndex = tokenIndexToGroup[_tokenId].contributorArr.push(userAdd);
tokenIndexToGroup[_tokenId].addressToContributorArrIndex[userAdd] = cIndex;
uint256 amountNeeded = SafeMath.sub(tokenPrice, group.contributedBalance);
if (msg.value > amountNeeded) {
tokenIndexToGroup[_tokenId].addressToContribution[userAdd] = amountNeeded;
tokenIndexToGroup[_tokenId].contributedBalance += amountNeeded;
userAddressToContributor[userAdd].withdrawableBalance += SafeMath.sub(msg.value, amountNeeded);
FundsDeposited(userAdd, SafeMath.sub(msg.value, amountNeeded));
} else {
tokenIndexToGroup[_tokenId].addressToContribution[userAdd] = msg.value;
tokenIndexToGroup[_tokenId].contributedBalance += msg.value;
}
uint256 gIndex = userAddressToContributor[userAdd].groupArr.push(_tokenId);
userAddressToContributor[userAdd].tokenIdToGroupArrIndex[_tokenId] = gIndex;
JoinGroup(
_tokenId,
userAdd,
tokenIndexToGroup[_tokenId].contributedBalance,
tokenIndexToGroup[_tokenId].addressToContribution[userAdd]
);
if (tokenIndexToGroup[_tokenId].contributedBalance >= tokenPrice) {
_purchase(_tokenId, tokenPrice);
}
}
| 1
| 5,665
|
function finishMinting() public whenNotPaused onlyOwner {
uint summaryTokensPercent = bountyTokensPercent.add(foundersTokensPercent);
uint mintedTokens = token.totalSupply();
uint totalSupply = mintedTokens.mul(percentRate).div(percentRate.sub(summaryTokensPercent));
uint foundersTokens = totalSupply.mul(foundersTokensPercent).div(percentRate);
uint bountyTokens = totalSupply.mul(bountyTokensPercent).div(percentRate);
uint foundersTokensMaster = foundersTokens.mul(slaveWalletPercent).div(percentRate);
uint foundersTokensSlave = foundersTokens.mul(percentRate.sub(slaveWalletPercent)).div(percentRate);
token.mint(this, foundersTokensMaster);
token.transfer(foundersTokensWalletMaster, foundersTokensMaster);
token.lock(foundersTokensWalletMaster, lockPeriod);
token.mint(this, foundersTokensSlave);
token.transfer(foundersTokensWalletSlave, foundersTokensSlave);
token.lock(foundersTokensWalletSlave, lockPeriod);
token.mint(this, bountyTokens);
token.transfer(bountyTokensWallet, bountyTokens);
totalTokensMinted = totalTokensMinted.add(foundersTokens).add(bountyTokens);
token.finishMinting();
}
| 1
| 9,482
|
function proposeToRemoveScheme(Avatar _avatar, address _scheme)
public
returns(bytes32)
{
bytes32 paramsHash = getParametersFromController(_avatar);
Parameters memory params = parameters[paramsHash];
IntVoteInterface intVote = params.intVote;
bytes32 proposalId = intVote.propose(2, params.voteRemoveParams, _avatar, ExecutableInterface(this),msg.sender);
organizationsProposals[_avatar][proposalId].proposalType = 2;
organizationsProposals[_avatar][proposalId].scheme = _scheme;
emit RemoveSchemeProposal(_avatar, proposalId, intVote, _scheme);
intVote.ownerVote(proposalId, 1, msg.sender);
return proposalId;
}
| 1
| 7,046
|
function getDefaultExchangeRate(
)
public
view
returns(uint256) {
return defaultExchangeRate;
}
| 0
| 13,899
|
function burnTokens(uint _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
totalSupply = totalSupply.sub(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
Burn(msg.sender, _value);
return true;
}
| 0
| 15,666
|
function _burnFrom(address _account, uint256 _amount) internal {
require(_amount <= allowed[_account][msg.sender]);
allowed[_account][msg.sender] = allowed[_account][msg.sender].sub(_amount);
emit Approval(_account, msg.sender, allowed[_account][msg.sender]);
_burn(_account, _amount);
}
| 0
| 19,202
|
function
* @param _proposalId id of the proposal
* @param _vote NO(2) or YES(1).
* @param _amount the betting amount
* @param _staker the staker address
* @return bool true - the proposal has been executed
* false - otherwise.
*/
function _stake(bytes32 _proposalId, uint _vote, uint _amount,address _staker) internal returns(bool) {
require(_vote <= NUM_OF_CHOICES && _vote > 0);
require(_amount > 0);
if (_execute(_proposalId)) {
return true;
}
Proposal storage proposal = proposals[_proposalId];
if (proposal.state != ProposalState.PreBoosted) {
return false;
}
Staker storage staker = proposal.stakers[_staker];
if ((staker.amount > 0) && (staker.vote != _vote)) {
return false;
}
uint amount = _amount;
Parameters memory params = parameters[proposal.paramsHash];
require(amount >= params.minimumStakingFee);
require(stakingToken.transferFrom(_staker, address(this), amount));
proposal.totalStakes[1] = proposal.totalStakes[1].add(amount);
staker.amount += amount;
staker.amountForBounty = staker.amount;
staker.vote = _vote;
proposal.votersStakes += (params.stakerFeeRatioForVoters * amount)/100;
proposal.stakes[_vote] = amount.add(proposal.stakes[_vote]);
amount = amount - ((params.stakerFeeRatioForVoters*amount)/100);
proposal.totalStakes[0] = amount.add(proposal.totalStakes[0]);
emit Stake(_proposalId, proposal.avatar, _staker, _vote, _amount);
return _execute(_proposalId);
}
| 1
| 3,362
|
function putCompanyOnsale(bytes32 nameFromUser, uint256 startPrice) public {
require(startPrice >= minCompanyValue);
require(startPrice <= maxCompanyValue);
bytes32 nameLowercase = utils.lowerCase(nameFromUser);
Company storage c = companies[nameLowercase];
require(c.owner != address(0));
require(c.owner == msg.sender);
require(c.isOnsale == false);
c.price = startPrice;
c.lastPrice = costContract.calculatePreviousPrice(c.price);
c.isOnsale = true;
emit CompanySaleStatusChanged(c.name, c.isOnsale, c.price, msg.sender);
}
| 1
| 5,584
|
function hasIssued(address account) external view returns (bool);
function incrementTotalIssuerCount() external;
function decrementTotalIssuerCount() external;
function setCurrentIssuanceData(address account, uint initialDebtOwnership) external;
function lastDebtLedgerEntry() external view returns (uint);
function appendDebtLedgerValue(uint value) external;
function clearIssuanceData(address account) external;
}
contract FeePoolState is SelfDestructible, LimitedSetup {
using SafeMath for uint;
using SafeDecimalMath for uint;
uint8 constant public FEE_PERIOD_LENGTH = 6;
address public feePool;
struct IssuanceData {
uint debtPercentage;
uint debtEntryIndex;
}
| 1
| 1,938
|
function subtractAction(bytes32 _requestId, uint256[] _subtractAmounts)
public
whenNotPaused
onlyRequestPayee(_requestId)
{
require(requestCore.getState(_requestId) != RequestCore.State.Canceled, "request should not be canceled");
require(
_subtractAmounts.length <= requestCore.getSubPayeesCount(_requestId).add(1),
"number of amounts should be <= number of payees"
);
for (uint8 i = 0; i < _subtractAmounts.length; i = i.add(1)) {
if (_subtractAmounts[i] != 0) {
require(
requestCore.getPayeeExpectedAmount(_requestId,i) >= _subtractAmounts[i].toInt256Safe(),
"subtract should equal or be lower than amount expected"
);
requestCore.updateExpectedAmount(_requestId, i, -_subtractAmounts[i].toInt256Safe());
}
}
}
| 0
| 18,736
|
modifier onlybyboardmember {if(_isBoardMember(tx.origin)) _ }
struct Proposal {
address newBoardMember;
uint placeInBoard;
uint givenstakes;
int ergebnis;
bool active;
mapping (address => bool) voted;
}
| 0
| 10,821
|
function validateRequestParams(
address[3] _addressArgs,
uint[12] _uintArgs,
uint _endowment
)
public view returns (bool[6])
{
return RequestLib.validate(
[
msg.sender,
_addressArgs[0],
_addressArgs[1],
_addressArgs[2]
],
_uintArgs,
_endowment
);
}
| 0
| 12,022
|
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize.cbAddress()) revert();
uint transactionID = oracalizeMyId2transactionID[myid];
Transaction memory transaction = transactions[transactionID];
if( bytes(result).length == 0 ) {
TransactionAborted(transactionID, "Oracalize return value was invalid, this is probably due to incorrect sendToOtherBlockchain() argments");
recoverable[transaction.returnAddress] += transaction.amount;
transaction.amount = 0;
}
else {
address depositAddress = parseAddr(result);
require(depositAddress != msg.sender);
uint sendAmount = transaction.amount;
transaction.amount = 0;
if (depositAddress.send(sendAmount))
TransactionSentToShapeShift(transactionID, transaction.returnAddress, depositAddress, sendAmount);
else {
TransactionAborted(transactionID, "transaction to address returned by Oracalize failed");
recoverable[transaction.returnAddress] += sendAmount;
}
}
}
| 1
| 4,870
|
function buyTokens(address _beneficiary) payable notEnded notPaused public {
require(msg.value >= 0);
uint256 stageIndex = getCurrentStage();
Stage storage stageCurrent = stages[stageIndex];
require(msg.value >= stageCurrent.minInvestment);
uint256 tokens;
if (stageCurrent.invested.add(msg.value) >= stageCurrent.hardcap){
stageCurrent.closed = now;
if (stageIndex + 1 <= stages.length - 1) {
Stage storage stageNext = stages[stageIndex + 1];
tokens = msg.value.mul(stageCurrent.price);
token.reserveTokens(_beneficiary, tokens, msg.value, 0);
stageNext.invested = stageCurrent.invested.add(msg.value);
stageCurrent.invested = stageCurrent.hardcap;
}
else {
tokens = msg.value.mul(stageCurrent.price);
token.reserveTokens(_beneficiary, tokens, msg.value, 0);
stageCurrent.invested = stageCurrent.invested.add(msg.value);
hasEnded = true;
}
}
else {
tokens = msg.value.mul(stageCurrent.price);
token.reserveTokens(_beneficiary, tokens, msg.value, 0);
stageCurrent.invested = stageCurrent.invested.add(msg.value);
}
emit TokenReservation(msg.sender, _beneficiary, msg.value, tokens);
forwardFunds();
}
| 1
| 3,877
|
function claimTokenReserve(address reserveWallet) internal {
require(allocations[reserveWallet] > 0, "There should be non-zero allocation.");
require(claimed[reserveWallet] == 0, "This address should be never claimed before.");
uint256 amount = allocations[reserveWallet];
claimed[reserveWallet] = amount;
require(token.transfer(reserveWallet, amount), "Token transfer failed");
emit Distributed(reserveWallet, amount);
}
| 1
| 5,245
|
function approve(
address _spender,
uint256 _value
)
public
lockupEnded(msg.sender, _spender)
returns (bool)
{
return super.approve(_spender, _value);
}
| 0
| 11,366
|
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.transfer(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.transfer(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
| 0
| 11,723
|
function distributeCastleLoot() external onlyUser {
require(now >= lastCastleLootDistributionTimestamp + config.castleLootDistributionThreshold(),
"not enough time passed since the last castle loot distribution");
lastCastleLootDistributionTimestamp = now;
uint128 luckFactor = generateLuckFactor(uint128(now % 1000));
if (luckFactor < 5) {
luckFactor = 5;
}
uint128 amount = castleTreasury * luckFactor / 100;
uint128 valueSum;
uint128[] memory shares = new uint128[](NUMBER_OF_LEVELS);
uint16 archersCount;
uint32[] memory archers = new uint32[](numCharacters);
uint8 cType;
for (uint8 i = 0; i < ids.length; i++) {
cType = characters[ids[i]].characterType;
if ((cType >= ARCHER_MIN_TYPE && cType <= ARCHER_MAX_TYPE)
&& (characters[ids[i]].fightCount >= 3)
&& (now - characters[ids[i]].purchaseTimestamp >= 7 days)) {
valueSum += config.values(cType);
archers[archersCount] = ids[i];
archersCount++;
}
}
if (valueSum > 0) {
for (uint8 j = 0; j < NUMBER_OF_LEVELS; j++) {
shares[j] = amount * config.values(ARCHER_MIN_TYPE + j) / valueSum;
}
for (uint16 k = 0; k < archersCount; k++) {
characters[archers[k]].value += shares[characters[archers[k]].characterType - ARCHER_MIN_TYPE];
}
castleTreasury -= amount;
emit NewDistributionCastleLoot(amount);
} else {
emit NewDistributionCastleLoot(0);
}
}
| 1
| 2,884
|
function weeklySettle() internal {
require(periodUpdateIndex >= WEEKLY_PERIOD);
address maxDrawdownThorMutualTokenAddress;
maxDrawdownThorMutualTokenAddress = thorMutualTokenPrice.getMaxWeeklyDrawdown(periodUpdateIndex);
if (maxDrawdownThorMutualTokenAddress == address(0)) {
return;
}
uint weeklyPeriod = (periodUpdateIndex - 1) / WEEKLY_PERIOD;
winnerWeeklyTokens[weeklyPeriod] = maxDrawdownThorMutualTokenAddress;
ThorMutualTokenInterface maxDrawdownThorMutualToken = ThorMutualTokenInterface(maxDrawdownThorMutualTokenAddress);
address[] memory participants;
(participants, ) = maxDrawdownThorMutualToken.getParticipantsWeekly(periodUpdateIndex - 1);
uint winnersLength = participants.length;
winnerWeeklyParticipantAmounts[weeklyPeriod] = winnersLength;
address winner;
uint maxDeposit = 0;
for (uint i = 0; i < winnersLength; i++) {
address rewardParticipant = participants[i];
uint depositAmountOfParticipant = maxDrawdownThorMutualToken.getParticipantAmountWeeklyPeriod(periodUpdateIndex - 1, rewardParticipant);
if(depositAmountOfParticipant > maxDeposit) {
winner = rewardParticipant;
maxDeposit = depositAmountOfParticipant;
}
}
winnerWeeklyAccounts[weeklyPeriod] = winner;
uint thorMutualWeeklyRewardFund = address(thorMutualWeeklyReward).balance;
uint winnerWeeklyAward = thorMutualWeeklyRewardFund * ratioWeekly / 10;
thorMutualWeeklyReward.settleWeekly(winner, winnerWeeklyAward);
winnerWeeklyParticipantInfos[weeklyPeriod][winner] = winnerWeeklyAward;
winnerWeeklyParticipantAddrs[weeklyPeriod] = winner;
winnerWeeklyParticipantAwards[weeklyPeriod] = winnerWeeklyAward;
}
| 1
| 3,714
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.