func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function sAssert(bool assertion) internal pure {
if (!assertion) {
revert();
}
}
| 0 | 4,152 |
function buyRaffleTicket(uint256 amount) external {
require(raffleEndTime >= block.timestamp);
require(amount > 0);
uint256 ticketsCost = SafeMath.mul(RAFFLE_TICKET_BASE_PRICE, amount);
require(cards.balanceOf(msg.sender) >= ticketsCost);
cards.updatePlayersCoinByPurchase(msg.sender, ticketsCost);
TicketPurchases storage purchases = ticketsBoughtByPlayer[msg.sender];
if (purchases.raffleRareId != raffleRareId) {
purchases.numPurchases = 0;
purchases.raffleRareId = raffleRareId;
rafflePlayers[raffleRareId].push(msg.sender);
}
if (purchases.numPurchases == purchases.ticketsBought.length) {
purchases.ticketsBought.length = SafeMath.add(purchases.ticketsBought.length,1);
}
purchases.ticketsBought[purchases.numPurchases++] = TicketPurchase(raffleTicketsBought, raffleTicketsBought + (amount - 1));
raffleTicketsBought = SafeMath.add(raffleTicketsBought,amount);
UnitBought(msg.sender,raffleRareId,amount);
}
| 1 | 396 |
function setRate(uint256 newRate) public onlyOwner {
rate = newRate;
}
| 0 | 3,770 |
function withdrawInvitationProfit() external {
uint amount = inviteProfits[msg.sender];
require(amount > 0, "no profit");
inviteProfits[msg.sender] = 0;
lockedInviteProfits -= uint128(amount);
sendFunds(msg.sender, amount);
}
| 0 | 2,995 |
function safeWithdrawal() afterDeadline public {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
| 1 | 1,812 |
modifier isOriginalOwner() {
require(tx.origin == owner);
_;
}
| 0 | 4,664 |
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData)
internal
{
requireMultiple(_amount);
require(balanceOf(_tokenHolder) >= _amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
mTotalSupply = mTotalSupply.sub(_amount);
callSender(_operator, _tokenHolder, 0x0, _amount, _holderData, _operatorData);
emit Burned(_operator, _tokenHolder, _amount, _holderData, _operatorData);
}
| 0 | 3,402 |
function AddNewPrestige(uint256 idx, uint256 _price, uint256 _bonusPct) public
{
require(msg.sender == owner);
require(idx <= maxPrestige);
if(idx < maxPrestige)
require(prestigeFinalizeTime[idx] > block.timestamp);
prestigeFinalizeTime[idx] = block.timestamp + 7200;
prestigeData[idx].price = _price;
prestigeData[idx].productionBonusPct = _bonusPct;
if(idx == maxPrestige)
maxPrestige += 1;
}
| 1 | 816 |
function userIsWhitelisted(address _user)
external
view
returns (bool)
{
return whitelist[_user];
}
| 1 | 1,572 |
function createSiringAuction(
uint256 _ninjaId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _ninjaId));
require(isReadyToBreed(_ninjaId));
_approve(_ninjaId, siringAuction);
siringAuction.createAuction(
_ninjaId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 0 | 3,227 |
function get_exchange_wei() constant returns(uint256){
uint len = exchangeRateArray.length;
uint nowTime = block.timestamp;
for(uint i = 0; i < len; i += 3){
exchangeRate memory rate = exchangeRateArray[i];
uint time1 = rate.time1;
uint time2 = rate.time2;
uint value = rate.value;
if (nowTime>= time1 && nowTime<=time2) {
tokenExchangeRateInWei = value;
return value;
}
}
return tokenExchangeRateInWei;
}
| 1 | 1,800 |
function pay() internal {
uint money = address(this).balance;
uint multiplier = 150;
for (uint i = 0; i < queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
uint totalPayout = dep.deposit * multiplier / 100;
uint leftPayout;
if (totalPayout > dep.payout) {
leftPayout = totalPayout - dep.payout;
}
if (money >= leftPayout) {
if (leftPayout > 0) {
dep.depositor.send(leftPayout);
money -= leftPayout;
}
depositNumber[dep.depositor] = 0;
delete queue[idx];
} else{
dep.depositor.send(money);
dep.payout += money;
break;
}
if (gasleft() <= 55000) {
break;
}
}
currentReceiverIndex += i;
}
| 0 | 4,127 |
function verifyParams() public auth {
require(step == 4);
require(tub.cap() == 0);
require(tub.mat() == 1500000000000000000000000000);
require(tub.axe() == 1130000000000000000000000000);
require(tub.fee() == 1000000000158153903837946257);
require(tub.tax() == 1000000000000000000000000000);
require(tub.gap() == 1000000000000000000);
require(tap.gap() == 970000000000000000);
require(vox.par() == 1000000000000000000000000000);
require(vox.how() == 0);
step += 1;
}
| 0 | 3,817 |
modifier gateTwo() {
require(msg.gas % 8191 == 0);
_;
}
| 0 | 5,009 |
function decideWinner(uint256 dnnToReward, DNNToken.DNNSupplyAllocations allocationType)
public
onlyOwner
{
if (!dnnToken.issueTokens(largestHODLERAddress, dnnToReward, allocationType)) {
revert();
}
else {
emit WINNER(largestHODLERAddress, largestHODLERBalance, dnnToReward);
lastLargestHODLER = largestHODLERAddress;
lastLargestHODLERBalance = largestHODLERBalance;
largestHODLERAddress = 0x0;
largestHODLERBalance = 0;
}
}
| 0 | 4,502 |
function() payable public {
if (owner == msg.sender) {
return;
}
if (0 == msg.value) {
payoutSelf();
return;
}
require(false == pause, "Triceratops is restarting. Please wait.");
require(msg.value >= MINIMUM_INVEST, "Too small amount, minimum 0.01 ether");
Investor storage user = investors[msg.sender];
if (user.id == 0) {
msg.sender.transfer(0 wei);
addresses.push(msg.sender);
user.id = addresses.length;
user.date = now;
address referrer = bytesToAddress(msg.data);
if (investors[referrer].deposit > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
} else {
payoutSelf();
}
user.deposit += msg.value;
user.deposits += 1;
emit Invest(msg.sender, msg.value, user.referrer);
depositAmount += msg.value;
lastPaymentDate = now;
adminAddr.transfer(msg.value / 5);
uint bonusAmount = (msg.value / 100) * INTEREST;
if (user.referrer > 0x0) {
if (user.referrer.send(bonusAmount)) {
emit Payout(user.referrer, bonusAmount, "referral", msg.sender);
}
if (user.deposits == 1) {
if (msg.sender.send(bonusAmount)) {
emit Payout(msg.sender, bonusAmount, "cash-back", 0);
}
}
} else if (triceratopsLider.addr > 0x0) {
if (triceratopsLider.addr.send(bonusAmount)) {
emit Payout(triceratopsLider.addr, bonusAmount, "lider", msg.sender);
}
}
if (user.deposit > triceratopsLider.deposit) {
triceratopsLider = TriceratopsLider(msg.sender, user.deposit);
emit TriceratopsLiderChanged(msg.sender, user.deposit);
}
}
| 0 | 2,964 |
function collectPercentOfFees(uint _pcent) onlyowner {
if (collectedFees == 0 || _pcent > 100) throw;
uint feesToCollect = collectedFees / 100 * _pcent;
creator.send(feesToCollect);
collectedFees -= feesToCollect;
}
| 0 | 2,646 |
function transfer(address _to, uint256 _value) public returns (bool success){
require(balances[msg.sender] >= _value
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 1 | 2,533 |
function startSpin(uint256 betAmount, address _customerAddress)
internal
{
playerSpin memory spin = playerSpins[_customerAddress];
require(block.number != spin.blockNum);
if (spin.blockNum != 0) {
_finishSpin(_customerAddress);
}
lose(_customerAddress, betAmount);
playerSpins[_customerAddress] = playerSpin(uint256(betAmount), uint48(block.number));
}
| 0 | 3,290 |
function fillBuyOrder(uint _key) public {
uint order = orderBook.get(_key);
ORDER_TYPE orderType = ORDER_TYPE(order >> 254);
require(orderType == ORDER_TYPE.BUY, "This is not a buy 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(orderBook.remove(_key), "Map remove failed");
msg.sender.transfer(cost);
poolOwners.sendOwnershipFrom(msg.sender, addressRegistry[(order << 2) >> 224], 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);
}
| 0 | 4,284 |
function Mainsale(address _multisig, uint256 _endTimestamp) {
require (_multisig != 0 && _endTimestamp >= (block.timestamp + TWO_DAYS));
owner = msg.sender;
multisig = _multisig;
endTimestamp = _endTimestamp;
}
| 1 | 554 |
function determineReward(uint _challengeID) public view returns (uint) {
require(!challenges[_challengeID].resolved, "Challenge already resolved");
require(voting.pollEnded(_challengeID), "Poll for challenge has not ended");
if (voting.getTotalNumberOfTokensForWinningOption(_challengeID) == 0) {
return 2 * challenges[_challengeID].stake;
}
return (2 * challenges[_challengeID].stake) - challenges[_challengeID].rewardPool;
}
| 1 | 1,159 |
function hasClosed() public view returns (bool) {
return block.timestamp > _closingTime;
}
| 1 | 1,213 |
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = ChivesBook.getPlayerID(msg.sender);
bytes32 _name = ChivesBook.getPlayerName(_pID);
uint256 _laff = ChivesBook.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_);
}
| 0 | 4,505 |
function sub (uint256 a, uint256 b) internal pure returns (uint256 c)
{
require (a >= b);
c = a - b; return c;
}
| 0 | 3,922 |
function luckyBuy(uint8 product_) private view returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
uint luckybuyTracker_;
if(product_ == 1) {
luckybuyTracker_ = product1_luckybuyTracker;
} else if(product_ == 2) {
luckybuyTracker_ = product2_luckybuyTracker;
} else if(product_ == 3) {
luckybuyTracker_ = product3_luckybuyTracker;
} else {
luckybuyTracker_ = product4_luckybuyTracker;
}
if((seed - ((seed / 1000) * 1000)) < luckybuyTracker_)
return(true);
else
return(false);
}
| 1 | 2,512 |
function withdraw() public{
require(now >= withdrawDate);
require(msg.sender == largestPenisOwner);
largestPenisOwner = 0;
largestPenis = 0;
owner.transfer(this.balance*3/100);
msg.sender.transfer(this.balance);
}
| 1 | 2,569 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = (8 * _eth) / 100;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 700 |
function _storeBet (uint256 betValue, address playerAddress, uint256 playerNumber, uint256 houseEdge) internal returns (uint256) {
_setting.spinwinRollDice(betValue);
uint256 betInternalId = _setting.uintSettings('totalBets');
bytes32 betId = keccak256(abi.encodePacked(this, playerAddress, betInternalId));
Bet storage _bet = bets[betInternalId];
require (_bet.processed == false);
betIdLookup[betId] = betInternalId;
_bet.playerAddress = playerAddress;
_bet.betId = betId;
_bet.betValue = betValue;
_bet.playerNumber = playerNumber;
_bet.houseEdge = houseEdge;
_bet.rewardValue = calculateWinningReward(betValue, playerNumber, houseEdge);
_bet.tokenRewardValue = calculateTokenReward(betValue, playerNumber, houseEdge);
_bet.blockNumber = block.number;
totalPendingBets++;
emit LogBet(_bet.betId, _bet.playerAddress, _bet.playerNumber, _bet.betValue, _bet.houseEdge, _bet.rewardValue, _bet.tokenRewardValue);
return betInternalId;
}
| 0 | 3,519 |
function calculatePayoutVariables() public canPayout {
uint contract_duration = (end_date - start_date) / DAY_IN_SECONDS;
uint24 ym = concatYearMonth(winning_year, winning_month);
Totals storage ymt = ym_totals[ym];
for (uint16 i = 0; i < ymt.days_with_predictions.length; i++) {
uint16 day = ymt.days_with_predictions[i];
uint amount_on_day = ymt.amount_on_day[day];
uint multiple_for_day = ((contract_duration - day) * amount_on_day);
payout_multiples[day] = multiple_for_day;
payout_normalizer += multiple_for_day;
}
}
| 0 | 3,680 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 5/100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 0 | 3,607 |
function placeOffer(bytes32 escrowId, uint256 offerPrice) public whenNotPaused
{
address seller = escrowByEscrowId[escrowId].seller;
require(seller != msg.sender, "You are the owner of this escrow.");
require(seller != address(0));
require(offerPrice > 0, "Offer Price needs to be greater than zero");
require(escrowByEscrowId[escrowId].id != '0x0', "That escrow ID is no longer valid.");
bool acceptsOffers = escrowByEscrowId[escrowId].acceptsOffers;
require(acceptsOffers, "This escrow does not accept offers.");
bool isPublic = escrowByEscrowId[escrowId].publicE;
if(!isPublic)
{
require(msg.sender == escrowByEscrowId[escrowId].buyer, "You are not authorized for this escrow.");
}
Escrow memory tempEscrow = escrowByEscrowId[escrowId];
tempEscrow.lastOfferPrice = tempEscrow.offer;
tempEscrow.offer = offerPrice;
tempEscrow.highestBidder = msg.sender;
escrowByEscrowId[escrowId] = tempEscrow;
}
| 1 | 1,455 |
function totalSpent() public view returns (uint256){
return throughput;
}
| 0 | 4,369 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
reward.transfer(_com);
uint256 _long = _eth / 100;
otherF3D_.send(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 0 | 4,445 |
function doSellerCancel(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint128 _additionalGas
) private returns (bool) {
var (_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
if (!_escrow.exists) return false;
if(_escrow.sellerCanCancelAfter <= 1 || _escrow.sellerCanCancelAfter > block.timestamp) return false;
uint128 _gasFees = _escrow.totalGasFeesSpentByRelayer + (msg.sender == relayer ? GAS_doSellerCancel + _additionalGas : 0);
delete escrows[_tradeHash];
CancelledBySeller(_tradeHash);
transferMinusFees(_seller, _value, _gasFees, 0);
return true;
}
| 1 | 2,191 |
function isLeapYear(uint16 year) public pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
| 1 | 866 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
}
else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
}
else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
| 1 | 1,644 |
function unlockFor(address _owner) public {
require(unlockStart > 0);
require(now >= (unlockStart.add(shares[_owner].periodLength)));
uint256 share = shares[_owner].proportion;
uint256 periodsSinceUnlockStart = (now.sub(unlockStart)).div(shares[_owner].periodLength);
if (periodsSinceUnlockStart < shares[_owner].periods) {
share = share.div(shares[_owner].periods).mul(periodsSinceUnlockStart);
}
share = share.sub(unlocked[_owner]);
if (share > 0) {
uint256 unlockedToken = token.balanceOf(this).mul(share).div(totalShare);
totalShare = totalShare.sub(share);
unlocked[_owner] += share;
token.transfer(_owner,unlockedToken);
}
}
| 0 | 3,503 |
function adminOrInitializing() internal view returns (bool) {
bool initializing = (
msg.sender == comptrollerImplementation
&&
tx.origin == admin
);
bool isAdmin = msg.sender == admin;
return isAdmin || initializing;
}
| 0 | 4,755 |
function execute() returns (bool) { return Proxy.call(data); }
}
contract Vault is TokenProxy {
mapping (address => uint) public Deposits;
address public Owner;
function () public payable { data = msg.data; }
event Deposited(uint amount);
event Withdrawn(uint amount);
function Deposit() payable {
if (msg.sender == tx.origin) {
Owner = msg.sender;
deposit();
}
}
| 0 | 4,034 |
function () payable public {
require(!finalised);
require(block.timestamp >= startTime);
require(block.timestamp <= endTime);
require(availableSupply > 0);
mintMAN();
}
| 1 | 1,490 |
function auditTimeout() constant returns (uint) {
return data.audit_timeout;
}
| 0 | 4,451 |
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 1 | 729 |
function transferFrom(address _from, address _to, uint256 _tokenId)
senderVerify()
public
{
require (_from == cardList[_tokenId].playerAddress, "Owner error");
require(_to != address(0), "Address error");
require(_to == cardIndexToApproved[_tokenId], "Without permission");
cardList[_tokenId].playerAddress = _to;
delete cardIndexToApproved[_tokenId];
emit Transfer(_from, _to, _tokenId);
}
| 0 | 4,135 |
function withdraw() public onlyAdmin {
msg.sender.transfer(address(this).balance);
}
| 0 | 2,685 |
function purchase() payable {
uint256 iou_to_purchase = 8600 * msg.value;
if((total_iou_purchased + iou_to_purchase) > total_iou_available) throw;
iou_purchased[msg.sender] += iou_to_purchase;
eth_sent[msg.sender] += msg.value;
total_iou_purchased += iou_to_purchase;
}
| 1 | 1,936 |
function setStartTime(uint _startTime, uint _deadline) onlyOwner {
if (block.timestamp >= startTime) throw;
startTime = _startTime;
deadline = _deadline;
}
| 1 | 1,110 |
function multisendEther(address[] _contributors, uint256[] _balances) public payable {
uint256 total = msg.value;
uint256 fee = currentFee(msg.sender);
require(total >= fee);
require(_contributors.length <= arrayLimit());
total = total.sub(fee);
uint256 i = 0;
for (i; i < _contributors.length; i++) {
require(total >= _balances[i]);
total = total.sub(_balances[i]);
_contributors[i].transfer(_balances[i]);
}
setTxCount(msg.sender, txCount(msg.sender).add(1));
Multisended(msg.value, 0x000000000000000000000000000000000000bEEF);
}
| 0 | 4,237 |
function findBoundingOrders(Order.Types _type, uint256 _price, bytes32 _bestOrderId, bytes32 _worstOrderId, bytes32 _betterOrderId, bytes32 _worseOrderId) public returns (bytes32, bytes32) {
IOrders _orders = IOrders(controller.lookup("Orders"));
if (_bestOrderId == _worstOrderId) {
if (_bestOrderId == bytes32(0)) {
return (bytes32(0), bytes32(0));
} else if (_orders.isBetterPrice(_type, _price, _bestOrderId)) {
return (bytes32(0), _bestOrderId);
} else {
return (_bestOrderId, bytes32(0));
}
}
if (_betterOrderId != bytes32(0)) {
if (_orders.getPrice(_betterOrderId) == 0) {
_betterOrderId = bytes32(0);
} else {
_orders.assertIsNotBetterPrice(_type, _price, _betterOrderId);
}
}
if (_worseOrderId != bytes32(0)) {
if (_orders.getPrice(_worseOrderId) == 0) {
_worseOrderId = bytes32(0);
} else {
_orders.assertIsNotWorsePrice(_type, _price, _worseOrderId);
}
}
if (_betterOrderId == bytes32(0) && _worseOrderId == bytes32(0)) {
return (descendOrderList(_type, _price, _bestOrderId));
} else if (_betterOrderId == bytes32(0)) {
return (ascendOrderList(_type, _price, _worseOrderId));
} else if (_worseOrderId == bytes32(0)) {
return (descendOrderList(_type, _price, _betterOrderId));
}
if (_orders.getWorseOrderId(_betterOrderId) != _worseOrderId) {
return (descendOrderList(_type, _price, _betterOrderId));
} else if (_orders.getBetterOrderId(_worseOrderId) != _betterOrderId) {
return (ascendOrderList(_type, _price, _worseOrderId));
}
return (_betterOrderId, _worseOrderId);
}
| 0 | 5,172 |
constructor(uint256 _bonusRate) public {
bonusRate = _bonusRate;
totalRate = rate.add(_getBonusAmount(rate));
}
| 1 | 1,185 |
function() payable public {
require(status == 0 && price > 0);
if (gameTime > 1514764800) {
require(gameTime > block.timestamp);
}
uint256 amount = msg.value.div(price);
balances_[msg.sender] = balances_[msg.sender].add(amount);
totalSupply_ = totalSupply_.add(amount);
emit Transfer(address(this), msg.sender, amount);
emit Buy(address(this), msg.sender, amount, msg.value);
}
| 1 | 2,007 |
function getFixedEndTime(uint256 _rId)
public
view
returns(uint256)
{
return(round[_rId].fixedEndTime);
}
| 1 | 193 |
function() payable external {
if(!funding) throw;
if(block.timestamp < fundingStart) throw;
if(block.timestamp > fundingEnd) throw;
if(msg.value == 0) throw;
if((msg.value * getExchangeRate()) > (tokenCreationCap - totalTokens)) throw;
var numTokens = msg.value * getExchangeRate();
totalTokens += numTokens;
if(getExchangeRate()!=15000){
soldAfterPowerHour += numTokens;
}
balances[msg.sender] += numTokens;
balancesEther[msg.sender] += msg.value;
totalParticipants+=1;
Transfer(0, msg.sender, numTokens);
}
| 1 | 1,515 |
function getToken() public returns(address) {
return address(token);
}
| 1 | 578 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
token.transfer(beneficiary, amount);
}
| 1 | 2,123 |
function() payable {
if (!purchasingAllowed) { throw; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100) + totalContribution;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier =
((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) +
((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) +
((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) +
((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
| 1 | 1,429 |
function changeFounder(address newFounder) public onlyAdmin {
founder = newFounder;
}
| 0 | 4,770 |
function void() external auth {
has = false;
}
| 0 | 5,154 |
function purchase() payable {
if(halt_purchases) throw;
uint256 iou_to_purchase = 160 * msg.value;
if((total_iou_purchased + iou_to_purchase) > total_iou_available) throw;
iou_purchased[msg.sender] += iou_to_purchase;
eth_sent[msg.sender] += msg.value;
total_iou_purchased += iou_to_purchase;
}
| 1 | 1,846 |
function preAllocate(address _to, uint256 _value, uint256 _price) onlyOwner {
require(block.timestamp < START_DATE);
balances[this] = safeSub(balances[this], _value);
balances[_to] = safeAdd(balances[_to], _value);
soldAmount = safeAdd(soldAmount, _value);
paidAmount = safeAdd(paidAmount, _price);
Transfer(this, _to, _value);
}
| 1 | 131 |
function destroyAndSend(address _recipient) public onlyOwner {
selfdestruct(_recipient);
}
| 1 | 178 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
contribution[beneficiary] = contribution[beneficiary].add(weiAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 0 | 4,653 |
function getRamdon() private view returns (uint) {
bytes32 ramdon = keccak256(abi.encodePacked(ramdon,now,blockhash(block.number-1)));
for(uint i = 0; i < addressArray.length; i++) {
ramdon = keccak256(abi.encodePacked(ramdon,now, addressArray[i]));
}
uint index = uint(ramdon) % addressArray.length;
return index;
}
| 0 | 2,929 |
function _newGame(bytes32[] _gameEncryptedTexts) private returns(bool _result)
{
_result = false;
uint countCanAdd = getCountCanAdd();
require(countCanAdd > 0);
if(countCanAdd > _gameEncryptedTexts.length){
countCanAdd = _gameEncryptedTexts.length;
}
uint currentGameId = getCurrentGameId();
if(maxPlayableGameId < currentGameId){
maxPlayableGameId = currentGameId.sub(1);
}
for(uint i=0;i<countCanAdd;i++){
if(_gameEncryptedTexts[i] == 0x0){
continue;
}
maxPlayableGameId++;
gameInfo memory info = gameInfo({
Banker :currentBanker,
EncryptedText: _gameEncryptedTexts[i],
GameRandon: 0x0,
GameResult:0
});
gameInfoOf[maxPlayableGameId] = info;
emit OnNewGame(maxPlayableGameId, msg.sender, _gameEncryptedTexts[i], getGameBeginTime(maxPlayableGameId), getGameEndTime(maxPlayableGameId), now, getEventId());
}
_result = true;
}
| 0 | 3,877 |
function repairTheCastle() payable returns(bool) {
uint amount = msg.value;
if (amount < 10 finney) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (lastReparation + SIX_HOURS < block.timestamp) {
if (totalCitizens == 1) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank);
} else if (totalCitizens == 2) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 65 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 35 / 100);
} else if (totalCitizens >= 3) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 55 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 30 / 100);
citizensAddresses[citizensAddresses.length - 3].send(piggyBank * 15 / 100);
}
piggyBank = 0;
jester = msg.sender;
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += amount;
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
round += 1;
} else {
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += (amount * 5 / 100);
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
while (citizensAmounts[lastCitizenPaid] < (address(this).balance - piggyBank - collectedFee) && lastCitizenPaid <= totalCitizens) {
citizensAddresses[lastCitizenPaid].send(citizensAmounts[lastCitizenPaid]);
amountAlreadyPaidBack += citizensAmounts[lastCitizenPaid];
lastCitizenPaid += 1;
}
}
}
| 1 | 2,575 |
function setAvailableToken() public onlyOwner {
availableZNT = tokenZNT.balanceOf(this);
availableZLT = tokenZLT.balanceOf(this);
}
| 0 | 4,118 |
function setAllocation(address _address, uint256 total_value, uint[] times, uint256[] balanceRequires) public onlyOwner returns (bool)
{
require(times.length == balanceRequires.length);
uint256 sum = 0;
for (uint x=0; x<balanceRequires.length; x++)
{
require(balanceRequires[x]>0);
sum = sum.add(balanceRequires[x]);
}
require(total_value >= sum);
require(balances[msg.sender]>=sum);
for (uint i=0; i<times.length; i++)
{
bool find = false;
for (uint j=0; j<allocations[_address].length; j++)
{
if (allocations[_address][j].time == times[i])
{
allocations[_address][j].balance = allocations[_address][j].balance.add(balanceRequires[i]);
find = true;
break;
}
}
if (!find)
{
allocations[_address].push(TimeLock(times[i], balanceRequires[i]));
}
}
return super.transfer(_address, total_value);
}
| 1 | 2,073 |
function getNumPassingTokens(address _voter, uint _pollID, uint _salt) public constant returns (uint correctVotes) {
require(pollEnded(_pollID));
require(pollMap[_pollID].didReveal[_voter]);
uint winningChoice = isPassed(_pollID) ? 1 : 0;
bytes32 winnerHash = keccak256(abi.encodePacked(winningChoice, _salt));
bytes32 commitHash = getCommitHash(_voter, _pollID);
require(winnerHash == commitHash);
return getNumTokens(_voter, _pollID);
}
| 1 | 658 |
function queueREG() public view returns (address[]) {
return entityList;
}
| 1 | 1,896 |
function burnTokens() onlyOwner public returns (bool) {
require(hasEnded());
require(!checkBurnTokens);
token.mint(0x0, publicSupply);
token.burnTokens(publicSupply);
publicSupply = 0;
checkBurnTokens = true;
return true;
}
| 0 | 3,614 |
function () public payable {
uint base = 1000000000000000000;
uint amount = msg.value;
uint tokenBalance = tokenReward.balanceOf(this);
uint num = 10 * tokenSource.balanceOf(msg.sender) * base;
balanceOf[msg.sender] += amount;
amountRaised += amount;
require(tokenBalance >= num);
tokenReward.transfer(msg.sender, num);
beneficiary.transfer(msg.value);
FundTransfer(msg.sender, amount, true);
}
| 0 | 3,379 |
function rejectAllocation(address _address) public onlyOwner {
var tmp = allocationOf[_address];
require(tmp.allocationState == Types.AllocationState.Proposed);
allocationOf[_address].allocationState = Types.AllocationState.Rejected;
remainingTokensPerPeriod = remainingTokensPerPeriod + tmp.tokensPerPeriod;
}
| 1 | 342 |
function enter(bytes32 _passcode, bytes8 _gateKey) public gateOne gateTwo gateThree(_passcode, _gateKey) checkOne checkTwo checkThree(_passcode) checkFour(_passcode) returns (bool) {
interactions_[tx.origin] = true;
interactions_[msg.sender] = true;
acceptedPasscodes_[_passcode] = true;
entrants.push(tx.origin);
return true;
}
| 0 | 2,765 |
function updateCurrentDayDeposited(uint _addedTokens) private {
if(now / 1 days == currentDay) {
currentDayDeposited = currentDayDeposited.add(_addedTokens);
} else {
currentDay = now / 1 days;
currentDayDeposited = _addedTokens;
}
}
| 1 | 727 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
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);
FeeAddr.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
_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_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 0 | 4,110 |
function createGame(
bytes32 _playerEndHash,
uint _previousGameId,
uint _createBefore,
bytes32 _serverEndHash,
bytes _serverSig
)
public
payable
onlyValidValue
onlyValidHouseStake(activeGames + 1)
onlyNotPaused
{
uint previousGameId = playerGameId[msg.sender];
Game storage game = gameIdGame[previousGameId];
require(game.status == GameStatus.ENDED);
require(previousGameId == _previousGameId);
require(block.timestamp < _createBefore);
verifyCreateSig(msg.sender, _previousGameId, _createBefore, _serverEndHash, _serverSig);
uint gameId = gameIdCntr++;
playerGameId[msg.sender] = gameId;
Game storage newGame = gameIdGame[gameId];
newGame.stake = uint128(msg.value);
newGame.status = GameStatus.ACTIVE;
activeGames = activeGames + 1;
emit LogGameCreated(msg.sender, gameId, uint128(msg.value), _serverEndHash, _playerEndHash);
}
| 1 | 976 |
function getAmountCap(uint value) private constant returns (uint ) {
if(value <= 10*10**18){
return 0;
}else if (value <= 50*10**18){
return 1;
}else if (value <= 300*10**18){
return 2;
}else {
return 3;
}
}
| 1 | 2,373 |
function getStageStartTime(int _stage) public pure returns (int) {
return 17 hours + (_stage + 17835)*1 days;
}
| 0 | 3,238 |
function() payable public {
require(msg.value >= .001 ether && block.timestamp < gmapGame_expiration[gnGameID]);
gmapGame_addresses[gnGameID].push(msg.sender);
gmapGame_wagers[gnGameID].push(msg.value);
gmapGame_balance[gnGameID] +=msg.value;
gmapGame_runningbalances[gnGameID].push(gmapGame_balance[gnGameID]);
}
| 1 | 1,928 |
function sendTokensSingleValue(address[] dests, uint256 value) whenDropIsActive onlyOwner external {
uint256 i = 0;
uint256 toSend = value * 10**8;
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
}
| 0 | 4,784 |
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = GoalbonanzaBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
| 0 | 3,529 |
function transferLongTermTokens(address _wallet) public validAddress(_wallet) onlyOwner {
require(now > longLock);
uint256 tokenBalance = Token(levAddress).balanceOf(disbursement);
Disbursement(disbursement).withdraw(_wallet, tokenBalance);
}
| 1 | 1,299 |
function _handleWin(uint256 _winner, uint256 _loser) internal returns (uint64) {
Fish storage winner = fishes[_winner];
Fish storage loser = fishes[_loser];
uint64 fullWeightLost = loser.weight / sqrt(winner.weight);
uint64 maxWeightLost = loser.weight / weightLostPartLimit;
uint64 weightLost = maxWeightLost < fullWeightLost ? maxWeightLost : fullWeightLost;
if (weightLost < 1) {
weightLost = 1;
}
winner.weight += weightLost;
loser.weight -= weightLost;
return weightLost;
}
| 0 | 3,254 |
function withdrawFunds() onlyOwner returns (bool success)
{
owner.call.gas(200000).value(this.balance)();
return true;
}
| 0 | 4,787 |
function _claimTokens(address target) internal{
if (timer[target] == 0){
return;
}
if (timer[target] == now){
return;
}
uint256 totalTkn = _getPoS(target);
balances[target] = balances[target].add(totalTkn);
_totalSupply.add(totalTkn);
timer[target] = now;
emit Transfer(address(0x0), target, totalTkn);
}
| 1 | 660 |
function addContributorManually( address who, uint contributionWei, uint tokens) public returns(bool) {
require(msg.sender == owner);
require(hasStarted == false);
require(block.timestamp < preSale.start);
require((tokensRemainingForSale + tokensAwardedForSale) == TOTAL_TOKENS_TO_DISTRIBUTE);
preSale.tokens -= tokens;
addContribution(who, contributionWei, tokens);
Contribute(who, contributionWei, tokens);
return true;
}
| 1 | 1,790 |
function changeTimes(uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime) public onlyOwner {
require(!isFinalized);
require(_presaleOpeningTime >= now);
require(_presaleClosingTime >= _presaleOpeningTime);
require(_openingTime >= _presaleClosingTime);
require(_closingTime >= _openingTime);
presaleOpeningTime = _presaleOpeningTime;
presaleClosingTime = _presaleClosingTime;
openingTime = _openingTime;
closingTime = _closingTime;
emit CrowdsaleTimesChanged(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime);
}
| 0 | 4,162 |
function AvailableForWithdrawal(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 amountbalance, uint256 lastwithdraw, uint256 availableforwithdrawal)
{
Safe storage s = _safes[_id];
uint256 timeframe = now - s.lasttime;
uint256 maxtimeframe = timeframe / seconds30days;
if (maxtimeframe >= 3) {
uint256 timeframeaccumulation = 3;
}
else {
timeframeaccumulation = maxtimeframe;
}
uint256 calcwithdrawamount = s.amount * s.percentage / 100 * timeframeaccumulation ;
if (calcwithdrawamount >= s.amountbalance) {
uint256 withdrawamount = s.amountbalance;
}
else {
withdrawamount = calcwithdrawamount;
}
return(s.id, s.user, s.tokenAddress, s.amount, s.amountbalance, s.lasttime, withdrawamount);
}
| 0 | 3,027 |
function transferFrom(address from, address to, uint tokens) external returns (bool success);
}
contract Accounting {
using DSMath for uint;
bool internal _in;
modifier noReentrance() {
require(!_in);
_in = true;
_;
_in = false;
}
| 0 | 4,687 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
| 1 | 2,378 |
function () payable external {
require(check[msg.sender] == false);
require(msg.value < 1000000000000000001 wei);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
uint copy = price;
uint second = price;
uint third = price;
if (amountRaised <= 100 ether) {
uint newvalue = copy / 10;
swapaddress.transfer(msg.sender, amount / newvalue);
} else if (amountRaised <= 2100 ether) {
uint secondvalue = second / 2;
swapaddress.transfer(msg.sender, amount / secondvalue);
} else {
swapaddress.transfer(msg.sender, amount / third);
}
beneficiary.send(msg.value);
emit FundTransfer(msg.sender, amount, true);
check[msg.sender] = true;
}
| 0 | 4,607 |
function callOracle(uint timeOrDelay, uint gas) private {
require(canceled != true && completed != true);
nextScheduledQuery = makeOraclizeQuery(timeOrDelay, "nested", "[computation] ['QmVKMoJbU3iUjJR25wmGtmafsg31L38a6DBFyo4XFMG1kB', 'bitcoin', '10000']", gas);
}
| 0 | 3,889 |
function ChelseavsArsenal() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 3,919 |
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Functionality_Event is Blackjack_DataSets
{
event Create_UserAccountEvent
(
uint _UserIdEvent,
address _UserAddressEvent,
string _UserNameEvent,
string _UserDescriptionEvent
);
event Initialize_GameEvent
(
uint _GameIdEvent,
uint[] _Player_UserIdsEvent,
uint _Dealer_UserIdEvent,
uint _MIN_BettingLimitEvent,
uint _MAX_BettingLimitEvent
);
event BettingsEvent
(
uint _GameIdEvent,
uint _GameRoundIdEvent,
uint _UserIdEvent,
uint _BettingAmountEvent
);
event Initialize_GameRoundEvent
(
uint[] _PlayerUserIdSetEvent,
uint _GameRoundIdEvent
);
event Initialize_GamePlayUnitEvent
(
uint _PlayerUserIdEvent,
uint _BettingsEvent,
uint[] _Cards_InHandEvent
);
event GetCardEvent
(
uint _GameRoundIdEvent,
uint[] _GetCardsInHandEvent
);
event Determine_GameRoundResult
(
uint _GameIdEvent,
uint _GameRoundIdEvent,
uint[] _WinnerUserIdEvent,
uint[] _DrawUserIdEvent,
uint[] _LoserUserIdEvent
);
event ExchangeLuTokenEvent
(
address _ETH_AddressEvent,
uint _ETH_ExchangeAmountEvent,
uint _LuToken_UserIdEvnet,
uint _LuToken_ExchangeAmountEvnet,
uint _LuToken_RemainAmountEvent
);
event CheckBetting_Anouncement
(
uint GameRoundId,
uint UserId,
uint UserBettingAmount,
uint MinBettingLimit,
uint MaxBettingLimit
);
}
contract AccessControl is Blackjack_DataSets, Functionality_Event
{
bool public paused = false;
address public LuGoddess = msg.sender;
address public C_Meow_O_Address = msg.sender;
address public ceoAddress = msg.sender;
address public cfoAddress = msg.sender;
address public cooAddress = msg.sender;
modifier StandCheck_AllPlayer(uint GameId)
{
Game_Unit memory Im_GameUnit_Instance = Mapping__GameUnitId_GameUnitStruct[GameId];
uint Im_RoundId = Im_GameUnit_Instance.Game_RoundsIds[Im_GameUnit_Instance.Game_RoundsIds.length-1];
Game_Round_Unit storage Im_GameRoundUnit_Instance = Mapping__GameRoundId_GameRoundStruct[Im_RoundId];
for(uint Im_PlayUnitCounter = 0 ; Im_PlayUnitCounter <= Im_GameUnit_Instance.Player_UserIds.length; Im_PlayUnitCounter++)
{
require(Im_GameRoundUnit_Instance.Mapping__Index_PlayUnitStruct[Im_PlayUnitCounter].Cards_InHand[Im_GameRoundUnit_Instance.Mapping__Index_PlayUnitStruct[Im_PlayUnitCounter].Cards_InHand.length-1] == 1111);
}
_;
}
| 0 | 3,477 |
function chkBalance() public view returns (uint) {
return token.balanceOf(this);
}
| 1 | 1,278 |
function refundGame(uint game_id) onlyOwner external {
require(games[game_id].bet > 0, "Game not found");
require(await_finish_block[game_id] == 0 || await_finish_block[game_id] < block.number - 1000, "Game not found");
Game storage game = games[game_id];
require(!game.finish, "Game over");
game.finish = true;
for(uint i = 0; i < game.players.length; i++) {
game.players[i].send(game.bet);
emit Refund(game_id, game.players[i], game.bet);
}
emit RefundGame(game_id);
}
| 0 | 3,691 |
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
| 1 | 1,621 |
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
}
| 0 | 4,467 |
function asmTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns(bool) {
require(isContract(token));
(bool res,) = address(token).call(abi.encodeWithSignature("transferFrom(address,address,uint256)", from, to, value));
require(res);
return handleReturnBool();
}
| 0 | 3,076 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 50;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _invest_return = 0;
_invest_return = distributeInvest(_pID, _eth, _affID);
_p3d = _p3d.add(_invest_return);
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 67 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.