func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function _openGameLoop() private returns(bool _result){
_result = false;
_checkOpenGame();
uint256 allAmount = 0;
for(uint i = 0; nextRewardPlayNo < playNo && i < currentRewardNum; i++ ){
betInfo storage p = playerBetInfoOf[nextRewardPlayNo];
if(!p.IsReturnAward){
_cashPrize(p, allAmount,nextRewardPlayNo);
}
nextRewardPlayNo = nextRewardPlayNo.add(1);
}
if(unpayPooling == 0 && _canSetGameOver()){
userTokenOf[currentBanker] = userTokenOf[currentBanker].add(userTokenOf[this]);
userTokenOf[this] = 0;
gameOver = true;
}
_result = true;
}
| 1
| 4,990
|
function getQueryId() constant public returns (uint) {
return uint(spinsByAddr[msg.sender].queryId);
}
| 0
| 11,794
|
function deposit(address investor) public onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
| 0
| 19,373
|
function rewardPay(address _user, uint256 amount) public {
require(msg.sender == commons.get("Crowdsale"));
rewardPayed[_user] = rewardPayed[_user].add(amount);
}
| 1
| 4,257
|
function buyItem(address _buyer, uint256 _tokenId, uint256 _affCode)
whenNotPaused()
external
{
uint256 _pId = determinePID(_buyer, _affCode);
require(artItemMap[_tokenId].isExist == true, "item not exist");
require(isItemSell(_tokenId) == false, "item already sold");
bool _isSuccess = YbTokenContract.transferFrom(_buyer, address(this), artItemMap[_tokenId].price);
require(_isSuccess, "yb transfer from failed");
artItemMap[_tokenId].owner = _buyer;
artItemMap[_tokenId].lastTransPrice = artItemMap[_tokenId].price;
artItemMap[_tokenId].buyYibPrice = YbTokenContract.getCurrentPrice();
artItemMap[_tokenId].buyTime = now;
playerMap[_pId].ownItemIds.push(_tokenId);
if(playerMap[_pId].laffId != 0) {
uint256 _affCut = (artItemMap[_tokenId].price).mul(affPercentCut).div(100);
address _affAddr = playerMap[playerMap[_pId].laffId].addr;
YbTokenContract.transfer(_affAddr, _affCut);
}
emit ArtChainEvents.onTransferItem ({
from: this,
to: _buyer,
itemId: _tokenId,
price: artItemMap[_tokenId].price,
yibPrice: artItemMap[_tokenId].buyYibPrice,
timeStamp: now
});
}
| 1
| 6,137
|
function order(uint256 _tokenId, uint256 orderAmount ,address buyer)
public
returns (bool)
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
_order(_tokenId, orderAmount,1);
_transfer(seller, _tokenId);
addressIndexToOrderCount[buyer][_calculateDayPass()] +=1;
bool flag = true;
return flag;
}
| 1
| 5,473
|
function settleBet(uint _betId, uint data) external onlyBot {
require(data != 0);
Bet storage bet = bets[_betId];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber);
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS);
uint amount = bet.amount;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
uint possibleWinAmount = getWinAmount(amount);
uint winAmount = 0;
uint seed = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty)));
uint random = data.add(seed);
if(bet.option == BLACK) {
winAmount = random % 2 == BLACK ? possibleWinAmount : 0;
}
if(bet.option == WHITE) {
winAmount = random % 2 == WHITE ? possibleWinAmount : 0;
}
if(winAmount > 0) {
require(address(this).balance >= minAmount + winAmount + teamBalance );
}
teamBalance = teamBalance.add(beneficiaryPercent(amount));
lockedInBets -= possibleWinAmount;
sendFunds(gambler, winAmount);
emit Reveal(_betId, data, seed, winAmount, gambler, bet.option);
}
| 0
| 14,164
|
constructor params
ZTHTKNADDR = ZethrAddress;
ZTHBANKROLL = BankrollAddress;
owner = msg.sender;
bankroll = ZTHBANKROLL;
ZTHTKN = ZTHInterface(ZTHTKNADDR);
ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
ZTHTKN.approve(owner, 2**256 - 1);
validTokenBet[1e18] = true;
validTokenBet[5e18] = true;
validTokenBet[10e18] = true;
validTokenBet[25e18] = true;
validTokenBet[50e18] = true;
gameActive = true;
}
function() public payable { }
struct TKN { address sender; uint value; }
function tokenFallback(address _from, uint _value, bytes ) public returns (bool){
if (_from == bankroll) {
contractBalance = contractBalance.add(_value);
return true;
}
| 1
| 6,735
|
function distributeTokens() onlyOwner public {
require(tokensSold >= goal);
require(tokensSold - tokensDistributed > 100);
uint256 toDistribute = tokensSold - tokensDistributed;
address bounties = 0x057Afd5422524d5Ca20218d07048300832323360;
address nirvana = 0x094d57AdaBa2278de6D1f3e2F975f14248C3775F;
address team = 0x7eC9d37163F4F1D1fD7E92B79B73d910088Aa2e7;
address club = 0xb2c032aF1336A1482eB2FE1815Ef301A2ea4fE0A;
uint256 bTokens = toDistribute * 1 / 65;
uint256 nTokens = toDistribute * 5 / 65;
uint256 tTokens = toDistribute * 10 / 65;
uint256 cTokens = toDistribute * 19 / 65;
token.mint(bounties, bTokens);
token.mint(nirvana, nTokens);
token.mint(team, tTokens);
token.mint(club, cTokens);
tokensDistributed = tokensDistributed.add(toDistribute);
}
| 1
| 1,254
|
function setTokenBaseURI(string _newBaseURI) external onlyOwner {
tokenBaseURI = _newBaseURI;
}
| 0
| 15,864
|
function withinPeriod() public view returns (bool) {
return now >= startTime && now <= endTime;
}
| 0
| 10,259
|
function transferGIM(address _from, address _to, uint256 _amount) returns (bool success) {
require(msg.sender == streamerContract);
require(tx.origin == _from);
require(_amount <= streamerContractMaxAmount);
if (balances[_from] < _amount || _amount <= 0)
return false;
balances[_from] = safeSub(balances[_from], _amount);
balances[_to] = safeAdd(balances[_to], _amount);
Transfer(_from, _to, _amount);
return true;
}
| 0
| 11,073
|
function initialize(address _permissionsCreator) public onlyInit {
initialized();
require(msg.sender == address(kernel()), ERROR_AUTH_INIT_KERNEL);
_createPermission(_permissionsCreator, this, CREATE_PERMISSIONS_ROLE, _permissionsCreator);
}
| 0
| 16,976
|
function loadEarlyPurchases() external onlyOwner returns (bool) {
if (earlyPurchasesLoaded) {
return false;
}
uint256 numOfOrigEp = starbaseEpAmendment
.starbaseEarlyPurchase()
.numberOfEarlyPurchases();
for (uint256 i = numOfLoadedEarlyPurchases; i < numOfOrigEp && msg.gas > 200000; i++) {
if (starbaseEpAmendment.isInvalidEarlyPurchase(i)) {
continue;
}
var (purchaser, amount,) =
starbaseEpAmendment.isAmendedEarlyPurchase(i)
? starbaseEpAmendment.amendedEarlyPurchases(i)
: starbaseEpAmendment.earlyPurchases(i);
if (amount > 0) {
if (earlyPurchasedAmountBy[purchaser] == 0) {
earlyPurchasers.push(purchaser);
}
uint256 bonus = SafeMath.mul(amount, 20) / 100;
uint256 amountWithBonus = SafeMath.add(amount, bonus);
earlyPurchasedAmountBy[purchaser] += amountWithBonus;
}
}
numOfLoadedEarlyPurchases += i;
assert(numOfLoadedEarlyPurchases <= numOfOrigEp);
if (numOfLoadedEarlyPurchases == numOfOrigEp) {
earlyPurchasesLoaded = true;
}
return true;
}
| 1
| 2,122
|
function withdraw(uint256 _gameID)
external
isHuman()
isActivated(_gameID)
isEnded(_gameID)
{
require(now < game_[_gameID].withdrawDeadline, "withdraw deadline already passed");
require(gameStatus_[_gameID].fundCleared == false, "fund already cleared");
uint256 _pID = BMBook.pIDxAddr_(msg.sender);
require(_pID != 0, "player has not played this game");
require(players_[_pID][_gameID].withdrawn == false, "player already cashed out");
players_[_pID][_gameID].withdrawn = true;
if (game_[_gameID].canceled) {
uint256 _totalInvestment = players_[_pID][_gameID].eth.mul(95) / 100;
if (_totalInvestment > 0) {
BMBook.getPlayerAddr(_pID).transfer(_totalInvestment);
gameStatus_[_gameID].totalWithdrawn = _totalInvestment.add(gameStatus_[_gameID].totalWithdrawn);
}
emit BMEvents.onWithdraw(_gameID, _pID, msg.sender, BMBook.getPlayerName(_pID), _totalInvestment, now);
} else {
uint256 _totalWinnings = getPlayerInstWinning(_gameID, _pID, game_[_gameID].winnerTeam).add(getPlayerPotWinning(_gameID, _pID, game_[_gameID].winnerTeam));
if (_totalWinnings > 0) {
BMBook.getPlayerAddr(_pID).transfer(_totalWinnings);
gameStatus_[_gameID].totalWithdrawn = _totalWinnings.add(gameStatus_[_gameID].totalWithdrawn);
}
emit BMEvents.onWithdraw(_gameID, _pID, msg.sender, BMBook.getPlayerName(_pID), _totalWinnings, now);
}
}
| 1
| 2,673
|
function updateTokenStatus() public
{
if(now < crowdfundDeadline){
tokensFrozen = true;
LogTokensFrozen(tokensFrozen);
}
if(now >= nextFreeze){
tokensFrozen = true;
LogTokensFrozen(tokensFrozen);
}
if(now >= nextThaw){
tokensFrozen = false;
nextFreeze = now + 12 * 1 weeks;
nextThaw = now + 13 * 1 weeks;
LogTokensFrozen(tokensFrozen);
}
}
| 0
| 12,302
|
function buyForWhitelisted() public payable {
require(token != address(0));
address whitelistedInvestor = msg.sender;
require(whitelist[whitelistedInvestor]);
uint256 weiToBuy = msg.value;
require(weiToBuy > 0);
uint256 tokenAmount = getTokenAmountForEther(weiToBuy);
require(tokenAmount > 0);
weiRaised = weiRaised.add(weiToBuy);
raisedByAddress[whitelistedInvestor] = raisedByAddress[whitelistedInvestor].add(weiToBuy);
forwardFunds(weiToBuy);
assert(token.mint(whitelistedInvestor, tokenAmount));
TokenPurchase(whitelistedInvestor, weiToBuy, tokenAmount);
}
| 1
| 8,217
|
constructors[newIndex] = MC({
playerAddress: msg.sender,
timeSince: block.number.add(vettingTime),
nextSharedSentTime: nextShareTime,
passed: false
}
| 1
| 3,953
|
function requestAudit(address _auditor, bytes32 _codeHash, uint _auditTime)
public whenNotPaused payable
{
require(_auditor != 0x0, "_auditor cannot be 0x0");
require(_auditTime >= MIN_AUDIT_TIME, "_auditTime should be >= MIN_AUDIT_TIME");
require(_auditTime <= MAX_AUDIT_TIME, "_auditTime should be <= MIN_AUDIT_TIME");
require(msg.value > 0, "msg.value should be >0");
uint8 outcome = SolidStampRegister(SolidStampRegisterAddress).getAuditOutcome(_auditor, _codeHash);
require(outcome == NOT_AUDITED, "contract already audited");
bytes32 hashAuditorCode = keccak256(abi.encodePacked(_auditor, _codeHash));
uint currentReward = Rewards[hashAuditorCode];
uint expireDate = now.add(_auditTime);
Rewards[hashAuditorCode] = currentReward.add(msg.value);
TotalRequestsAmount = TotalRequestsAmount.add(msg.value);
bytes32 hashAuditorRequestorCode = keccak256(abi.encodePacked(_auditor, msg.sender, _codeHash));
AuditRequest storage request = AuditRequests[hashAuditorRequestorCode];
if ( request.amount == 0 ) {
AuditRequests[hashAuditorRequestorCode] = AuditRequest({
amount : msg.value,
expireDate : expireDate
});
emit AuditRequested(_auditor, msg.sender, _codeHash, msg.value, expireDate);
} else {
request.amount = request.amount.add(msg.value);
if ( expireDate > request.expireDate )
request.expireDate = expireDate;
emit AuditRequested(_auditor, msg.sender, _codeHash, request.amount, request.expireDate);
}
}
| 1
| 1,516
|
function _unsafeCall(address _to, uint _amount) internal {
require(_to != 0);
_to.call.value(_amount)();
}
| 0
| 15,557
|
function claimGameReward(address _champion, uint _lockedTokenAmount, uint _lockTime) returns (uint error){
if (lockdown) throw;
if (msg.sender != creditGameAddress) { return 1; }
uint newCreditsIssued = creditBond.getNewCoinsIssued(
_lockedTokenAmount,
_lockTime,
creditBond.getBondMultiplier(_lockedTokenAmount, _lockTime + block.number));
if (newCreditsIssued == 0) { return 1; }
mint(newCreditsIssued, _champion);
return 0;
}
| 1
| 3,611
|
function GoldBackedToken(GoldFees feeCalc, GBTBasic _oldToken) public {
uint delta = 3799997201200178500814753;
feeCalculator = feeCalc;
oldToken = _oldToken;
uint x;
for (x = 0; x < oldToken.aotLength(); x++) {
Allocation memory al;
(al.amount, al.date) = oldToken.allocationsOverTime(x);
allocationsOverTime.push(al);
}
allocationsOverTime[3].amount = allocationsOverTime[3].amount.sub(delta);
for (x = 0; x < oldToken.currentAllocationLength(); x++) {
(al.amount, al.date) = oldToken.currentAllocations(x);
al.amount = al.amount.sub(delta);
currentAllocations.push(al);
}
mintedGBT.date = 1515700247;
mintedGBT.amount = 1529313490861692541644;
}
| 1
| 791
|
function finishICO() public onlyOwner returns (bool) {
uint frozenBalance = balances[msg.sender]/2;
transfer(frozenWallet2y, frozenBalance);
transfer(frozenWallet4y, balances[msg.sender]);
transferAllowed = true;
return true;
}
| 0
| 10,624
|
function fillSellOrder(uint _key) public payable {
uint order = orderBook.get(_key);
ORDER_TYPE orderType = ORDER_TYPE(order >> 254);
require(orderType == ORDER_TYPE.SELL, "This is not a sell order");
uint index = addressRegister(msg.sender);
require(index != (order << 2) >> 224, "You cannot fill your own order");
uint price = (order << 34) >> 145;
uint amount = (order << 145) >> 145;
uint orderFee = feeForOrder(price, amount);
require(feeBalances[index] >= orderFee, "You do not have enough deposited fees to fill this order");
uint cost = price.mul(amount).div(1 ether);
require(msg.value == cost, "ETH sent needs to equal the cost");
require(orderBook.remove(_key), "Map remove failed");
addressRegistry[(order << 2) >> 224].transfer(msg.value);
poolOwners.sendOwnership(msg.sender, amount);
if (orderFee > 0) {
feeBalances[index] = feeBalances[index].sub(orderFee);
feeBalances[0] = feeBalances[0].add(orderFee);
lockedFees = lockedFees.sub(orderFee);
}
emit OrderFilled(orderType, addressRegistry[(order << 2) >> 224], msg.sender, price, amount);
}
| 1
| 1,865
|
function ico( address _to, uint256 _val ) internal returns(bool) {
require( token != address(0) );
require( isActive() );
require( _val >= ( 1 ether / 10 ) );
require( totalCollected < hardCap );
uint256 tokensAmount = _val.mul( icoPrice ) / 10**10;
if ( ( icoBonus > 0 ) && ( totalSold.add(tokensAmount) < maxTokensWithBonus ) ) {
tokensAmount = tokensAmount.add( tokensAmount.mul(icoBonus) / 1000000 );
} else {
icoBonus = 0;
}
require( totalSold.add(tokensAmount) < token.maxSupply() );
require( token.issueDuringICO(_to, tokensAmount) );
wingsTokenRewards = wingsTokenRewards.add( tokensAmount.mul( wingsTokenRewardsPercent ) / 1000000 );
wingsETHRewards = wingsETHRewards.add( _val.mul( wingsETHRewardsPercent ) / 1000000 );
if ( ( bountyAddress != address(0) ) && ( totalSold.add(tokensAmount) < maxTokensWithBonus ) ) {
require( token.issueDuringICO(bountyAddress, tokensAmount.mul(bountyPercent) / 1000000) );
tokensAmount = tokensAmount.add( tokensAmount.mul(bountyPercent) / 1000000 );
}
totalCollected = totalCollected.add( _val );
totalSold = totalSold.add( tokensAmount );
return true;
}
| 1
| 337
|
function setOnceMintAmount(uint256 _value) onlyMultiOwners public {
require(hasAuth(AUTH_SETMINTAMOUNT));
require(_value > 0);
onceMintAmount = _value;
clearAuth(AUTH_SETMINTAMOUNT);
}
| 0
| 13,229
|
function finalization() internal {
super.finalization();
uint256 toMintNow = totalTokens.mul(25).div(100);
if (!capIncreased) {
toMintNow = toMintNow.add(50 * 1000 * 1000);
}
_deliverTokens(tokensWallet, toMintNow);
}
| 1
| 8,898
|
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user,
uint amount, uint oldBlockNumber,string orderId) public {
bytes32 hash = sha256(abi.encodePacked(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce));
require (orders[user][hash] && block.number <= (oldBlockNumber + expires) && safeAdd(orderFills[user][hash], amount) <= amountGet);
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
uint orderFilled = orderFills[user][hash];
uint amountSent = (amountGive * amount / amountGet);
emit Trade(tokenGet, amountGet, amount, tokenGive, amountGive, amountSent, user, msg.sender, orderId, orderFilled);
}
| 1
| 2,344
|
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool) {
Mortgage storage mortgage = mortgages[uint256(readBytes32(data, 0))];
require(mortgage.engine == engine, "Engine does not match");
require(mortgage.loanId == index, "Loan id does not match");
require(mortgage.status == Status.Pending, "Mortgage is not pending");
require(engines[engine], "Engine not authorized");
mortgage.status = Status.Ongoing;
_generate(uint256(readBytes32(data, 0)), mortgage.owner);
uint256 loanAmount = convertRate(engine.getOracle(index), engine.getCurrency(index), oracleData, engine.getAmount(index));
require(rcn.transferFrom(mortgage.owner, this, loanAmount), "Error pulling RCN from borrower");
uint256 boughtMana = convertSafe(mortgage.tokenConverter, rcn, mana, loanAmount);
delete mortgage.tokenConverter;
uint256 currentLandCost;
(, , currentLandCost, ) = mortgage.landMarket.auctionByAssetId(mortgage.landId);
require(currentLandCost <= mortgage.landCost, "Parcel is more expensive than expected");
require(mana.approve(mortgage.landMarket, currentLandCost), "Error approving mana transfer");
flagReceiveLand = mortgage.landId;
mortgage.landMarket.executeOrder(mortgage.landId, currentLandCost);
require(mana.approve(mortgage.landMarket, 0), "Error removing approve mana transfer");
require(flagReceiveLand == 0, "ERC721 callback not called");
require(land.ownerOf(mortgage.landId) == address(this), "Error buying parcel");
land.setUpdateOperator(mortgage.landId, mortgage.owner);
uint256 totalMana = boughtMana.add(mortgage.deposit);
uint256 rest = totalMana.sub(currentLandCost);
require(mana.transfer(mortgage.owner, rest), "Error returning MANA");
require(mortgage.engine.cosign(index, 0), "Error performing cosign");
mortgageByLandId[mortgage.landId] = uint256(readBytes32(data, 0));
emit StartedMortgage(uint256(readBytes32(data, 0)));
return true;
}
| 1
| 4,004
|
function startUnitRaffle(uint256 endTime, uint256 unitId) external {
require(msg.sender == owner);
require(block.timestamp < endTime);
if (unitRaffleRareId != 0) {
require(unitRaffleWinner != 0);
}
unitRaffleWinningTicketSelected = false;
unitRaffleTicketThatWon = 0;
unitRaffleWinner = 0;
unitRaffleTicketsBought = 0;
unitRaffleEndTime = endTime;
unitRaffleRareId = unitId;
unitRaffleId++;
}
| 0
| 18,432
|
function proposalExpirationTime(address wallet, MonetaryTypesLib.Currency memory currency)
public
view
returns (uint256)
{
uint256 index = proposalIndexByWalletCurrency[wallet][currency.ct][currency.id];
require(0 != index, "No proposal found for wallet and currency [NullSettlementChallengeState.sol:340]");
return proposals[index - 1].expirationTime;
}
| 0
| 10,010
|
function getSlideEndTime(uint256 _rId)
public
view
returns(uint256)
{
return(round[_rId].slideEndTime);
}
| 0
| 19,388
|
function getBackLendingItem(uint64 _objId) isActive external {
EtheremonTradeData monTradeData = EtheremonTradeData(tradingMonDataContract);
BorrowItem memory borrowItem;
(borrowItem.index, borrowItem.owner, borrowItem.borrower, borrowItem.price, borrowItem.lent, borrowItem.createTime, borrowItem.releaseTime) = monTradeData.getBorrowInfo(_objId);
if (borrowItem.index == 0)
revert();
if (borrowItem.lent == false)
revert();
if (borrowItem.releaseTime > block.timestamp)
revert();
if (msg.sender != borrowItem.owner)
revert();
monTradeData.removeBorrowingItem(_objId);
EtheremonDataBase data = EtheremonDataBase(dataContract);
data.removeMonsterIdMapping(borrowItem.borrower, _objId);
data.addMonsterIdMapping(msg.sender, _objId);
EtheremonMonsterNFTInterface monsterNFT = EtheremonMonsterNFTInterface(monsterNFTContract);
monsterNFT.triggerTransferEvent(borrowItem.borrower, msg.sender, _objId);
monTradeData.removeItemLendingList(msg.sender, _objId);
EventGetBackItem(msg.sender, borrowItem.borrower, _objId);
}
| 0
| 16,354
|
function payoutSize(address _to) view public returns(uint) {
uint max = investors[_to].invested.mul(MULTIPLICATION);
if(investors[_to].invested == 0 || investors[_to].payouts >= max) return 0;
uint payout = investors[_to].invested.mul(bonusSize()).div(100).mul(block.timestamp.sub(investors[_to].last_payout)).div(1 days);
return investors[_to].payouts.add(payout) > max ? max.sub(investors[_to].payouts) : payout;
}
| 0
| 10,572
|
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18))
)-tokenPriceIncremental_
)*(tokens_ - 1e18)
),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2
)
/1e18);
return _etherReceived;
}
| 0
| 16,953
|
function isTransfersPaused() public view returns (bool) {
return !availability.transfersEnabled;
}
| 0
| 19,328
|
function shareProfits() onlyOwner {
if (profitsLockedUntil > now) throw;
if (currentBankroll <= initialBankroll) throw;
uint256 profit = currentBankroll - initialBankroll;
if (!ADMIN_CONTRACT.call.value(profit)()) throw;
currentBankroll -= profit;
bankrollLockedUntil = now + BANKROLL_LOCK_PERIOD;
profitsLockedUntil = bankrollLockedUntil + BANKROLL_LOCK_PERIOD;
}
| 1
| 6,105
|
constructor(
uint256[] _xPoints,
uint256[] _yPoints,
uint256 _startTime,
uint256 _landsLimitPerBid,
uint256 _gasPriceLimit,
ERC20 _manaToken,
LANDRegistry _landRegistry,
address _dex
) public {
Ownable.initialize(msg.sender);
require(_startTime > block.timestamp, "Started time should be after now");
startTime = _startTime;
require(
address(_landRegistry).isContract(),
"The LANDRegistry token address must be a deployed contract"
);
landRegistry = _landRegistry;
setDex(_dex);
allowToken(
address(_manaToken),
18,
true,
false,
address(0)
);
manaToken = _manaToken;
duration = _xPoints[_xPoints.length - 1];
require(duration > 24 * 60 * 60, "The duration should be greater than 1 day");
_setCurve(_xPoints, _yPoints);
setLandsLimitPerBid(_landsLimitPerBid);
setGasPriceLimit(_gasPriceLimit);
status = Status.created;
emit AuctionCreated(
msg.sender,
startTime,
duration,
initialPrice,
endPrice
);
}
| 0
| 10,513
|
function sale(address beneficiary, uint256 value, address referrer) internal {
require(crowdsaleOpen());
require(value > 0);
collectedEther = collectedEther.add(value);
contributions[beneficiary] = contributions[beneficiary].add(value);
uint256 amount;
if(referrer == address(0)){
amount = getTokensWithBonuses(value, false);
} else{
amount = getTokensWithBonuses(value, true);
uint256 referrerAmount = getReferrerBonus(value);
tokensSold = tokensSold.add(referrerAmount);
mintTokens(referrer, referrerAmount);
}
tokensSold = tokensSold.add(amount);
mintTokens(beneficiary, amount);
}
| 1
| 8,600
|
function validateContentHash(address _student, uint _docIndx, bytes32 _contentHash) public view returns(bool) {
Certification storage certification = studentCertifications[_student];
return (certification.documents[_docIndx]).validateContentHash(_contentHash);
}
| 0
| 14,867
|
function finishIco(
address _teamFund,
address _bountyFund
)
external teamOnly
{
require(icoState == IcoState.Running || icoState == IcoState.Paused);
atl.mint(_teamFund, 22500000 * 1e18);
atl.mint(_bountyFund, 18750000 * 1e18);
atl.unfreeze();
icoState = IcoState.Finished;
FinishIco(_teamFund, _bountyFund);
}
| 1
| 6,541
|
function buyAgain(uint256 _amount) public isHuman whenNotPaused {
require(smallRound[bigId][smallId].startTime < block.timestamp, "The game has not started yet");
require(smallRound[bigId][smallId].endTime > block.timestamp, "The game is over");
uint256 _money = _amount.mul(getPrice());
uint256 profit = getMyProfit(bigId);
require(_amount > 0 && _money > 0);
require(profit >= _money);
bigRound[bigId].received[msg.sender] = _money.add(bigRound[bigId].received[msg.sender]);
_buy(_amount, _money);
}
| 0
| 17,513
|
function getGameDrawInfos() external view
returns (
uint carryOverJackpot,
uint totalTicketCount,
uint totalWinPlayersCount,
uint[] totalWinCount,
uint[] playersAmounts
)
{
uint jackpotAmounts = (games[gameNumber].tickets.length * games[gameNumber].ticketPrice) + games[gameNumber].accumJackpotAmounts;
jackpotAmounts -= ((games[gameNumber].tickets.length * games[gameNumber].ticketPrice) * adminFee) / 100;
totalWinCount = new uint[](numbersCount + 1);
playersAmounts = new uint[](numbersCount + 1);
uint winNumberCount;
uint sendedJackpotAmounts;
for(uint i = 0; i < games[gameNumber].tickets.length; i++) {
for (uint k = 0; k < games[gameNumber].winningNumbers.length; k++) {
if(games[gameNumber].winNumMapping[games[gameNumber].tickets[i].numbers[k]]) {
winNumberCount++;
}
}
if(prizeStart <= winNumberCount) {
totalWinCount[winNumberCount]++;
totalWinPlayersCount++;
}
winNumberCount = 0;
}
for(i = prizeStart; i < numbersCount + 1; i++) {
if(0 < totalWinCount[i]) {
playersAmounts[i] = (jackpotAmounts * winPercent[i] / 100) / totalWinCount[i];
sendedJackpotAmounts += (jackpotAmounts * winPercent[i] / 100);
}
}
carryOverJackpot = jackpotAmounts - sendedJackpotAmounts;
totalTicketCount = games[gameNumber].tickets.length;
}
| 1
| 8,149
|
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
| 1
| 33
|
function sendTokensToAdvisors(address _advisorsAddress) public onlyOwner returns (bool) {
require (_advisorsAddress != address(0x0));
require (!sendedToAdvisors);
require (sale.getEndDate() > 0 && now > sale.getEndDate());
sendedToAdvisors = true;
_mint(_advisorsAddress, advisorsPart);
return true;
}
| 1
| 1,076
|
function withdrawPurchasedTokens()
external
whenEnded
returns (bool)
{
assert(earlyPurchasesLoaded);
assert(address(starbaseToken) != 0);
if (crowdsalePurchaseAmountBy[msg.sender] > 0) {
uint256 crowdsalePurchaseValue = crowdsalePurchaseAmountBy[msg.sender];
crowdsalePurchaseAmountBy[msg.sender] = 0;
uint256 tokenCount =
SafeMath.mul(crowdsaleTokenAmount, crowdsalePurchaseValue) /
totalAmountOfPurchasesInCny;
numOfPurchasedTokensOnCsBy[msg.sender] =
SafeMath.add(numOfPurchasedTokensOnCsBy[msg.sender], tokenCount);
assert(starbaseToken.allocateToCrowdsalePurchaser(msg.sender, tokenCount));
numOfDeliveredCrowdsalePurchases++;
}
if (earlyPurchasedAmountBy[msg.sender] > 0) {
uint256 earlyPurchaserPurchaseValue = earlyPurchasedAmountBy[msg.sender];
earlyPurchasedAmountBy[msg.sender] = 0;
uint256 epTokenCalculationFromEPTokenAmount = SafeMath.mul(earlyPurchaseTokenAmount, earlyPurchaserPurchaseValue) / totalAmountOfEarlyPurchasesInCny;
uint256 epTokenCalculationFromCrowdsaleTokenAmount = SafeMath.mul(crowdsaleTokenAmount, earlyPurchaserPurchaseValue) / totalAmountOfPurchasesInCny;
uint256 epTokenCount = SafeMath.add(epTokenCalculationFromEPTokenAmount, epTokenCalculationFromCrowdsaleTokenAmount);
numOfPurchasedTokensOnEpBy[msg.sender] = SafeMath.add(numOfPurchasedTokensOnEpBy[msg.sender], epTokenCount);
assert(starbaseToken.allocateToCrowdsalePurchaser(msg.sender, epTokenCount));
numOfDeliveredEarlyPurchases++;
}
return true;
}
| 1
| 311
|
function addMeByRC(address _ambassadorAddr) public {
require(tx.origin == owner);
ambassadorAddressOf[ msg.sender ] = _ambassadorAddr;
NewAmbassador(_ambassadorAddr, msg.sender);
}
| 0
| 18,306
|
function getUserTotalEthVolumeSaldo(address userAddress) public view returns (uint256 res) {
for (uint256 i = 0; i < _controllerContractCount; i++) {
res = SafeMath.add(res, _userEthVolumeSaldos[Etherama(_controllerIndexer[i]).getDataContractAddress()][userAddress]);
}
}
| 0
| 11,847
|
function donate() payable public {
sk2xContract.call(msg.value);
}
| 0
| 11,907
|
function _preValidatePreICOPurchase(address _beneficiary, uint256 _weiAmount) internal view {
require(_weiAmount != 0);
require(whitelist[_beneficiary]);
require(now >= preICOStartDate && now <= preICOEndDate);
}
| 0
| 11,914
|
function setMinesPrice () public {
var lvl1MinePrice = getUSD()*10;
for (uint8 lvl=0; lvl<13; lvl++) {
if (lvl<=2)
minesPrice[lvl] = (lvl+1)*lvl1MinePrice;
else
minesPrice[lvl] = minesPrice[lvl-1]+minesPrice[lvl-2];
}
}
| 1
| 8,776
|
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;
}
| 0
| 18,717
|
function getStockBuyOrderPrices(uint _node) constant public returns(uint[] _prices) {
_prices = sCVars.stockBuyOrderPrices[_node];
}
| 0
| 14,521
|
function getClaimAmount(address investor) public constant returns (uint) {
if(getState() != State.Distributing) {
throw;
}
return balances[investor].times(tokensBought) / weiRaised;
}
| 0
| 11,408
|
function () payable external
{
require(now>startTime);
require(now<=endTime);
uint256 amount=0;
processFunding(msg.sender,msg.value,rate);
amount=msg.value.mul(rate);
totalFundingSupply = totalFundingSupply.add(amount);
}
| 1
| 239
|
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
FDDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1
| 5,158
|
function withdrawBack() public
{
require(state == State.Disabled);
uint256 tokens = investors[msg.sender];
uint256 value = div( tokens, etherPrice );
if (value > 0)
{
investors[msg.sender] = 0;
require( msg.sender.call.gas(gasPrice).value(value)() );
totalSupply = sub( totalSupply, tokens );
}
}
| 1
| 6,510
|
function recalcFlags() public {
if (block.timestamp >= deadline || token.balanceOf(this) <= 0)
crowdsaleClosed = true;
if (amountRaised >= goalInEthers)
goalReached = true;
}
| 1
| 472
|
function changeBankroll(address _newBankrollAddress)
onlyAdministrator
public
{
bankrollAddress = _newBankrollAddress;
}
| 0
| 15,899
|
function collectFeesInEther(uint _amt) onlyowner {
_amt *= 1 ether;
if (_amt > collectedFees) collectAllFees();
if (collectedFees == 0) throw;
creator.send(_amt);
collectedFees -= _amt;
}
| 0
| 17,238
|
function purchaseTokens(address _beneficiary) public payable inProgress {
require(msg.value >= 0.01 ether);
uint256 tokens = computeTokenAmount(msg.value);
doIssueTokens(_beneficiary, tokens);
owner.transfer(this.balance);
}
| 0
| 12,189
|
function icoPhaseCore(uint256 _pID, uint256 _eth, uint256 _team, uint256 _affID, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
if ((round_[_rID].ico).keysRec(_eth) >= 1000000000000000000 || round_[_rID].plyr == 0)
{
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
plyrRnds_[_pID][_rID].ico = _eth.add(plyrRnds_[_pID][_rID].ico);
round_[_rID].ico = _eth.add(round_[_rID].ico);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
round_[_rID].icoGen = _gen.add(round_[_rID].icoGen);
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
uint256 _pot = (_eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100))).sub(_gen);
round_[_rID].pot = _pot.add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
endTx(_rID, _pID, _team, _eth, 0, _eventData_);
}
| 1
| 5,270
|
function Crowdsale(address _tokenAddress) public{
token = BineuroToken(_tokenAddress);
techSupport = msg.sender;
token.setCrowdsaleContract(this);
owner = token.getOwner();
}
| 1
| 1,745
|
function HashToken() {
prev_hash = sha3(block.blockhash(block.number));
max_value = 2 ** 255;
name = 'HashToken';
decimals = 16;
symbol = 'HTK';
}
| 0
| 19,069
|
function sendFlower(address _truelove, bytes32 _registerID, string _letter, bytes16 _date, uint _amount) public payable sendCheck(_registerID) {
require(flowerBalances[msg.sender] >= _amount);
flowerBalances[msg.sender] -= _amount;
flowerBalances[_truelove] += (_amount * 9 / 10);
GiftSend(giftSendIndex, _truelove, msg.sender, _registerID, _letter, _date,
GiftType.Flower,
flower.model,
flower.year,
0,
_amount
);
giftSendIndex++;
}
| 0
| 19,315
|
function claimTokensBC(uint8 order) onlyOwner public {
require(finished);
require(order >= 1 && order <= 4);
require(!completedBC[order]);
if (order == 1) {
require(now >= endICODate + 15724800);
token.transfer(walletB, paymentSizeB);
token.transfer(walletC, paymentSizeC);
completedBC[order] = true;
}
if (order == 2) {
require(now >= endICODate + 31536000);
token.transfer(walletB, paymentSizeB);
token.transfer(walletC, paymentSizeC);
completedBC[order] = true;
}
if (order == 3) {
require(now >= endICODate + 47260800);
token.transfer(walletB, paymentSizeB);
token.transfer(walletC, paymentSizeC);
completedBC[order] = true;
}
if (order == 4) {
require(now >= endICODate + 63072000);
token.transfer(walletB, paymentSizeB);
token.transfer(walletC, paymentSizeC);
completedBC[order] = true;
}
}
| 1
| 4,256
|
function distributeAff(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID)
private
returns(uint256)
{
uint256 _addP3d = 0;
uint256 _aff1 = _eth.div(10);
uint256 _aff2 = _eth.div(20);
uint256 _aff3 = _eth.div(100).mul(3);
groupCut.transfer(_aff1);
if ((_affID != 0) && (_affID != _pID) && (plyr_[_affID].name != ''))
{
plyr_[_pID].laffID = _affID;
plyr_[_affID].aff = _aff2.add(plyr_[_affID].aff);
emit BigOneEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff2, now);
uint256 _secLaff = plyr_[_affID].laffID;
if((_secLaff != 0) && (_secLaff != _pID))
{
plyr_[_secLaff].aff = _aff3.add(plyr_[_secLaff].aff);
emit BigOneEvents.onAffiliatePayout(_secLaff, plyr_[_secLaff].addr, plyr_[_secLaff].name, _rID, _pID, _aff3, now);
} else {
_addP3d = _addP3d.add(_aff3);
}
} else {
_addP3d = _addP3d.add(_aff2);
}
return(_addP3d);
}
| 1
| 5,280
|
function __callback(bytes32 callbackId, string result, bytes proof) onlyOraclize public {
require(callbackId == queryId_, "callbackId is error");
if (queryTryCount_ == 1) {
updateGasPrice();
checkQueryRandom();
}
else {
queryRandomCallback(callbackId, result, proof);
}
}
| 0
| 12,628
|
function fund() public payable onlyOwner {
assert(!funded);
originalTotalSupply = lifToken.totalSupply();
initialWei = msg.value;
initialBuyPrice = initialWei.
mul(PRICE_FACTOR).
div(originalTotalSupply);
funded = true;
}
| 0
| 19,182
|
constructor(MatchingMarket _matchingMarket, Maker _maker, ProxyRegistry _proxyRegistry) public payable {
providerFeePerEth = 0.01 ether;
matchingMarket = _matchingMarket;
maker = _maker;
dai = maker.sai();
weth = maker.gem();
peth = maker.skr();
mkr = maker.gov();
dai.approve(address(_matchingMarket), uint256(-1));
weth.approve(address(_matchingMarket), uint256(-1));
dai.approve(address(_maker), uint256(-1));
mkr.approve(address(_maker), uint256(-1));
weth.approve(address(_maker), uint256(-1));
peth.approve(address(_maker), uint256(-1));
proxyRegistry = _proxyRegistry;
if (msg.value > 0) {
weth.deposit.value(msg.value)();
}
}
| 1
| 1,024
|
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
require(msg.value!=0);
uint newTokens = (msg.value * getMntTokensPerEth(icoTokensSold)) / 1 ether;
issueTokensInternal(_buyer,newTokens);
ethInvestedBy[msg.sender] = safeAdd(ethInvestedBy[msg.sender], msg.value);
}
| 1
| 4,718
|
function deprecate(bool deprecated_, address nextContract_) public onlyAdmin {
isContractDeprecated = deprecated_;
nextContract = nextContract_;
}
| 0
| 17,284
|
function mine(uint amount) canMine public {
require(amount > 0);
require(cycleMintSupply < CYCLE_CAP);
require(ERC20(MNY).transferFrom(msg.sender, address(this), amount));
uint refund = _mine(exchangeRateMNY, amount);
if(refund > 0) {
ERC20(MNY).transfer(msg.sender, refund);
}
if (cycleMintSupply == CYCLE_CAP) {
_startSwap();
}
}
| 0
| 14,975
|
function passPeriod() public {
require(now-lastPeriodChange >= timePerPeriod[uint8(period)]);
if (period == Period.Activation) {
rnBlock = block.number + 1;
rng.requestRN(rnBlock);
period = Period.Draw;
} else if (period == Period.Draw) {
randomNumber = rng.getUncorrelatedRN(rnBlock);
require(randomNumber != 0);
period = Period.Vote;
} else if (period == Period.Vote) {
period = Period.Appeal;
} else if (period == Period.Appeal) {
period = Period.Execution;
} else if (period == Period.Execution) {
period = Period.Activation;
++session;
segmentSize = 0;
rnBlock = 0;
randomNumber = 0;
}
lastPeriodChange = now;
NewPeriod(period, session);
}
| 1
| 2,906
|
function reinvest(uint256 _referrerCode, uint256 _planId) public payable {
require(msg.value == 0, "Reinvest doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
uint256 availableInvestAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
availableInvestAmount = availableInvestAmount.add(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends = uid2Investor[uid].plans[i].currentDividends.add(amount);
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
availableInvestAmount = availableInvestAmount.add(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (_invest(msg.sender, _planId, _referrerCode, availableInvestAmount, true)) {
emit onReinvest(msg.sender, availableInvestAmount);
}
}
| 0
| 11,899
|
function claimPrize() public payable onlyWinner {
winner.transfer(address(this).balance);
}
| 0
| 10,128
|
function GetFileLocation(bytes32 key) constant returns (uint Loc) {
return files[key].length -1;
}
| 0
| 12,162
|
function tradeIn(address smellyOldToken, uint amount) public returns (bool) {
ERC20WithDecimals oldToken = ERC20WithDecimals(smellyOldToken);
oldToken.safeTransferFrom(msg.sender, owner, amount);
uint pnbCount = amount * (uint(10) ** decimals) / (uint(10) ** oldToken.decimals());
require(totalSupply.add(pnbCount) < maxTotalSupply);
totalSupply = totalSupply.add(pnbCount);
balances[msg.sender] = balances[msg.sender].add(pnbCount);
Transfer(0x0, msg.sender, pnbCount);
return true;
}
| 1
| 1,703
|
function mint(address _to, uint256 _amount) public
onlyOwner
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
| 0
| 17,703
|
function sell(uint256 bidId, uint256 amount) public {
BidInfo storage bidInfo = bidInfos[bidId];
ERC20 erc20 = ERC20(bidInfo.token);
require(erc20.balanceOf(msg.sender) >= amount);
require(erc20.allowance(msg.sender, this) >= amount);
require(bidInfo.amount >= amount);
uint256 realPrice = amount.mul(bidInfo.price).div(bidInfo.amount);
require(realPrice.mul(bidInfo.amount) == amount.mul(bidInfo.price));
erc20.transferFrom(msg.sender, bidInfo.bidder, amount);
bidInfo.price = bidInfo.price.sub(realPrice);
bidInfo.amount = bidInfo.amount.sub(amount);
if (bidInfo.amount == 0) {
removeBid(bidId);
}
msg.sender.transfer(realPrice);
emit Sell(bidId, amount);
}
| 1
| 3,743
|
function loves_getLoves(uint256 _countryId, address _player) public view returns (uint256 loves_) {
LoverStructure storage c = loversSTR[gameVersion][_countryId];
return c.loves[howManyNuked][_player];
}
| 0
| 11,355
|
function setOPM(address _newOPM) public onlyLeader {
require(_newOPM != address(0));
opmAddress = _newOPM;
}
| 0
| 18,330
|
function executeOrder (
address[4] _token_and_EOA_Addresses,
uint256[8] _amountsExpirationAndSalt,
uint8[2] _sig_v,
bytes32[4] _sig_r_and_s
) public
returns(bool)
{
Wallet[2] memory wallets = [
Wallet(userAccountToWallet_[_token_and_EOA_Addresses[0]]),
Wallet(userAccountToWallet_[_token_and_EOA_Addresses[2]])
];
if(!__executeOrderInputIsValid__(
_token_and_EOA_Addresses,
_amountsExpirationAndSalt,
wallets[0],
wallets[1]
))
return error('Input is invalid, Exchange.executeOrder()');
bytes32 makerOrderHash;
bytes32 takerOrderHash;
(makerOrderHash, takerOrderHash) = __generateOrderHashes__(_token_and_EOA_Addresses, _amountsExpirationAndSalt);
if (!__signatureIsValid__(
_token_and_EOA_Addresses[0],
makerOrderHash,
_sig_v[0],
_sig_r_and_s[0],
_sig_r_and_s[1]
))
return error('Maker signature is invalid, Exchange.executeOrder()');
if (!__signatureIsValid__(
_token_and_EOA_Addresses[2],
takerOrderHash,
_sig_v[1],
_sig_r_and_s[2],
_sig_r_and_s[3]
))
return error('Taker signature is invalid, Exchange.executeOrder()');
Order memory makerOrder = orders_[makerOrderHash];
Order memory takerOrder = orders_[takerOrderHash];
if (makerOrder.wantTokenTotal_ == 0) {
makerOrder.active_ = true;
makerOrder.offerToken_ = _token_and_EOA_Addresses[1];
makerOrder.offerTokenTotal_ = _amountsExpirationAndSalt[0];
makerOrder.offerTokenRemaining_ = _amountsExpirationAndSalt[0];
makerOrder.wantToken_ = _token_and_EOA_Addresses[3];
makerOrder.wantTokenTotal_ = _amountsExpirationAndSalt[1];
makerOrder.wantTokenReceived_ = 0;
}
if (takerOrder.wantTokenTotal_ == 0) {
takerOrder.active_ = true;
takerOrder.offerToken_ = _token_and_EOA_Addresses[3];
takerOrder.offerTokenTotal_ = _amountsExpirationAndSalt[2];
takerOrder.offerTokenRemaining_ = _amountsExpirationAndSalt[2];
takerOrder.wantToken_ = _token_and_EOA_Addresses[1];
takerOrder.wantTokenTotal_ = _amountsExpirationAndSalt[3];
takerOrder.wantTokenReceived_ = 0;
}
if (!__ordersMatch_and_AreVaild__(makerOrder, takerOrder))
return error('Orders do not match, Exchange.executeOrder()');
uint256 toTakerAmount;
uint256 toMakerAmount;
(toTakerAmount, toMakerAmount) = __getTradeAmounts__(makerOrder, takerOrder);
if (toTakerAmount < 1 || toMakerAmount < 1)
return error('Token amount < 1, price ratio is invalid! Token value < 1, Exchange.executeOrder()');
if (
takerOrder.offerToken_ == edoToken_ &&
Token(edoToken_).balanceOf(wallets[1]) < __calculateFee__(makerOrder, toTakerAmount, toMakerAmount).add(toMakerAmount)
) {
return error('Taker has an insufficient EDO token balance to cover the fee AND the offer, Exchange.executeOrder()');
} else if (Token(edoToken_).balanceOf(wallets[1]) < __calculateFee__(makerOrder, toTakerAmount, toMakerAmount))
return error('Taker has an insufficient EDO token balance to cover the fee, Exchange.executeOrder()');
if (!__ordersVerifiedByWallets__(
_token_and_EOA_Addresses,
toMakerAmount,
toTakerAmount,
wallets[0],
wallets[1],
__calculateFee__(makerOrder, toTakerAmount, toMakerAmount)
))
return error('Order could not be verified by wallets, Exchange.executeOrder()');
__updateOrders__(makerOrder, takerOrder, toTakerAmount, toMakerAmount);
if (makerOrder.offerTokenRemaining_ == 0)
makerOrder.active_ = false;
if (takerOrder.offerTokenRemaining_ == 0)
takerOrder.active_ = false;
orders_[makerOrderHash] = makerOrder;
orders_[takerOrderHash] = takerOrder;
require(
__executeTokenTransfer__(
_token_and_EOA_Addresses,
toTakerAmount,
toMakerAmount,
__calculateFee__(makerOrder, toTakerAmount, toMakerAmount),
wallets[0],
wallets[1]
)
);
LogOrderFilled(makerOrderHash, toTakerAmount, makerOrder.offerTokenRemaining_);
LogOrderFilled(takerOrderHash, toMakerAmount, takerOrder.offerTokenRemaining_);
LogOrderExecutionSuccess();
return true;
}
| 1
| 7,155
|
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
| 1
| 7,571
|
function HardcodedCrowdsale (uint _preICOstart, uint _preICOend, uint _preICOgoal, uint _preICOcap, address _newLedgerAddress) public {
require(_preICOstart > now);
require(_preICOend > _preICOstart);
require(_preICOgoal > 0);
require(_newLedgerAddress != address(0));
preICOstart = _preICOstart;
preICOend = _preICOend;
preICOgoal = _preICOgoal;
preICOcap = _preICOcap;
managedTokenLedger = ManagedToken(_newLedgerAddress);
decimals = managedTokenLedger.decimals();
DECIMAL_MULTIPLIER = 10**uint256(decimals);
}
| 1
| 4,203
|
function NCAAChampionship() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0
| 11,860
|
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
require(!safeguard);
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
| 0
| 16,116
|
function refund(address _participantAddress) public {
Swap memory swap = swaps[msg.sender][_participantAddress];
require(swap.balance > uint256(0));
require(swap.createdAt.add(SafeTime) < now);
msg.sender.transfer(swap.balance);
Reputation(ratingContractAddress).change(_participantAddress, -1);
clean(msg.sender, _participantAddress);
Refund();
}
| 1
| 6,346
|
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
| 1
| 7,030
|
function testRandom() public view returns (uint[] numbers) {
numbers = new uint[](32);
Random.Data memory r;
for(uint i=0; i<256; i+=8){
numbers[i/8] = Random.random(r, 10);
}
}
| 0
| 18,428
|
function _supportMarket(address asset, InterestRateModel interestRateModel) public returns (uint) {
if (msg.sender != admin) {
return fail(Error.UNAUTHORIZED, FailureInfo.SUPPORT_MARKET_OWNER_CHECK);
}
(Error err, Exp memory assetPrice) = fetchAssetPrice(asset);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPORT_MARKET_FETCH_PRICE_FAILED);
}
if (isZeroExp(assetPrice)) {
return fail(Error.ASSET_NOT_PRICED, FailureInfo.SUPPORT_MARKET_PRICE_CHECK);
}
markets[asset].interestRateModel = interestRateModel;
addCollateralMarket(asset);
markets[asset].isSupported = true;
if (markets[asset].supplyIndex == 0) {
markets[asset].supplyIndex = initialInterestIndex;
}
if (markets[asset].borrowIndex == 0) {
markets[asset].borrowIndex = initialInterestIndex;
}
emit SupportedMarket(asset, interestRateModel);
return uint(Error.NO_ERROR);
}
| 1
| 7,681
|
function fixedLog2(uint256 _x, uint8 _precision) constant returns (uint256) {
uint256 fixedOne = ONE << _precision;
uint256 fixedTwo = TWO << _precision;
assert( _x >= fixedOne);
uint256 hi = 0;
while (_x >= fixedTwo) {
_x >>= 1;
hi += fixedOne;
}
for (uint8 i = 0; i < _precision; ++i) {
_x = (_x * _x) / fixedOne;
if (_x >= fixedTwo) {
_x >>= 1;
hi += ONE << (_precision - 1 - i);
}
}
return hi;
}
| 0
| 12,845
|
function()
isActivated()
senderVerify()
amountVerify()
payable
public
{
buyAnalysis(0x0);
}
| 0
| 18,170
|
function _createUnicorn(address _owner) private returns(uint256) {
require(gen0Count < gen0Limit);
uint256 newUnicornId = unicornToken.createUnicorn(_owner);
blackBox.createGen0.value(unicornManagement.oraclizeFee())(newUnicornId);
emit CreateUnicorn(_owner, newUnicornId, 0, 0);
gen0Count = gen0Count.add(1);
return newUnicornId;
}
| 1
| 5,858
|
function betPlaced(address _gambler, uint256 _amount, uint256 _winningChance) external
{
require(addressIsStakeDiceGameContract[msg.sender] == true);
uint N = 4;
uint delay = 0;
uint callbackGas = 90000;
bytes32 queryId = oraclize_newRandomDSQuery(delay, N, callbackGas);
uint256 potentialRevenue = StakeDiceGame(msg.sender).multiplierOnWin() * _amount / 10000;
BetPlaced(_gambler, bets.length);
oraclizeQueryIdsToBetIndices[queryId] = bets.length;
bets.push(Bet({gambler: _gambler, winningChance: _winningChance, betAmount: _amount, potentialRevenue: potentialRevenue, roll: 0, status: BetStatus.IN_PROGRESS}));
if (playersToTotalBets[_gambler] == 0)
{
allPlayers.push(_gambler);
}
playersToTotalBets[_gambler] += _amount;
}
| 0
| 12,141
|
function deposit() payable public limitBuy() {
require(msg.value > 1000000);
uint256 amountCredited = (msg.value * multiplier) / 100;
participants.push(Participant(msg.sender, amountCredited));
backlog += amountCredited;
creditRemaining[msg.sender] += amountCredited;
emit Deposit(msg.value, msg.sender);
if(myDividends() > 0){
withdraw();
}
payout();
}
| 0
| 12,797
|
function initialization() internal {
uint256 taxValue = TaxValues[vaultNum];
vaultNum++;
uint256 arrear;
if (address(vault) != 0x0){
arrear = DistributorRefundVault(vault).taxValue();
vault.del(wallets[uint8(Roles.beneficiary)]);
}
vault = new DistributorRefundVault(TaxCollector, taxValue.add(arrear));
}
| 1
| 9,315
|
function transfer(address _to, uint256 _value) public canTransfer(msg.sender, _to, _value) returns (bool) {
preTransfer(msg.sender, _to, _value);
return super.transfer(_to, _value);
}
| 0
| 17,622
|
constructor(address _base_token, address _traded_token,uint256 _base_token_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public {
admin = tx.origin;
base_token = _base_token;
traded_token = _traded_token;
base_token_seed_amount = _base_token_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
}
| 0
| 11,506
|
function discoverResources(uint cityTokenId_) public {
require(contractActive);
require(discoveryBlocksUntilAllowed(cityTokenId_) == 0);
uint yccAmount = this.discoveryPrice(cityTokenId_);
ycc.payForUpgrade(msg.sender, yccAmount);
discoveryLastBlock[cityTokenId_] = block.number;
uint resourceRichnessLen = cityResourceRichness[cityTokenId_].length;
for (uint i = 0; i < resourceRichnessLen; i++) {
cityResourceCount[cityTokenId_][i] += cityResourceRichness[cityTokenId_][i];
}
ResourcesDiscovered(cityTokenId_);
}
| 1
| 2,357
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.