func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function transfer(address to, uint256 index) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender || msg.sender == loan.approvedTransfer || operators[loan.lender][msg.sender]);
require(to != address(0));
lendersBalance[loan.lender] -= 1;
lendersBalance[to] += 1;
Transfer(loan.lender, to, index);
loan.lender = to;
loan.approvedTransfer = address(0);
return true;
}
| 0 | 1,754 |
function() payable external {
if(hasRole("manager", msg.sender)) {
require(msg.data.length > 0, "Send the address in data");
address addr = bytesToAddress(msg.data);
require(!hasRole("manager", addr) && admins[addr].percent == 0, "This address is manager");
if(!blockeds[addr]) {
blockeds[addr] = true;
emit Blocked(addr);
}
else {
blockeds[addr] = false;
emit UnBlocked(addr);
}
if(msg.value > 0) {
msg.sender.transfer(msg.value);
}
return;
}
if(investors[msg.sender].invested > 0 && !blockeds[msg.sender]) {
_checkReinvest(msg.sender);
uint payout = payoutSize(msg.sender);
require(msg.value > 0 || payout > 0, "No payouts");
if(payout > 0) {
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].payouts = investors[msg.sender].payouts.add(payout);
msg.sender.transfer(payout);
emit Payout(msg.sender, payout);
}
}
if(msg.value > 0) {
require(msg.value >= 0.01 ether, "Minimum investment amount 0.01 ether");
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].invested = investors[msg.sender].invested.add(msg.value);
beneficiary.transfer(msg.value.mul(COMMISSION).div(100));
if(investors[msg.sender].first_invest == 0) {
investors[msg.sender].first_invest = block.timestamp;
if(msg.data.length > 0) {
address ref = bytesToAddress(msg.data);
if(ref != msg.sender && investors[ref].invested > 0 && msg.value >= 1 ether) {
investors[msg.sender].referrer = ref;
uint ref_bonus = msg.value.mul(REFBONUS).div(100);
ref.transfer(ref_bonus);
emit RefBonus(msg.sender, ref, ref_bonus);
uint cashback_bonus = msg.value.mul(CASHBACK).div(100);
investors[msg.sender].invested = investors[msg.sender].invested.add(cashback_bonus);
emit CashBack(msg.sender, cashback_bonus);
}
}
}
_reCalcTop(msg.sender);
emit Deposit(msg.sender, msg.value, investors[msg.sender].referrer);
}
}
| 0 | 2,730 |
function distributedToOwner(uint256 _value) private
{
gameSponsor.send(_value);
miningWarAdministrator.send(_value);
}
| 1 | 692 |
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 4;
}
tokens = tokens + bonus;
sendtokens(thetoken, tokens, investor);
}
| 1 | 818 |
function addParticipant(address _address, address _referrer) payable public {
require(participants[_address] == address(0), "This participant is already registered");
require(msg.value >= 0.45 ether && msg.value <= 225 ether, "Deposit should be between 0.45 ether and 225 ether (45 days)");
participants[_address] = address(new Participant(_address, msg.value / 45));
processPayment(_address);
processing.send(msg.value / 33);
if (_referrer != address(0) && referrers[_referrer]) {
_referrer.send(msg.value / 20);
}
emit ParticipantAdded(_address);
}
| 1 | 1,386 |
function preparePayment() public
{
uint totalInteres = getInteres(msg.sender);
uint paidInteres = user[msg.sender].paidInteres;
if (totalInteres > paidInteres)
{
uint amount = totalInteres.sub(paidInteres);
emit LogPreparePayment(msg.sender, totalInteres, paidInteres, amount);
user[msg.sender].paidInteres = user[msg.sender].paidInteres.add(amount);
transfer(msg.sender, amount);
}
else
{
emit LogSkipPreparePayment(msg.sender, totalInteres, paidInteres);
}
}
| 0 | 2,195 |
function buyTokens(string _account) public payable {
require(!stringEqual(_account, ""));
require(validPurchase());
require(msg.value >= minCount);
if(!stringEqual(bindAddressAccounts[msg.sender], "")) {
require(stringEqual(bindAddressAccounts[msg.sender], _account));
}
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
require(token.call(bytes4(keccak256("mint(address,uint256)")), msg.sender, tokens));
bindAccountsAddress[_account] = msg.sender;
bindAddressAccounts[msg.sender] = _account;
accounts.push(_account);
weiRaised = weiRaised.add(weiAmount);
forwardFunds();
}
| 0 | 2,123 |
function addPool(uint ticketPrice, uint ticketCount, uint duration) public
{
require(msg.sender == owner);
require(ticketPrice >= ticketPriceMultiple && ticketPrice % ticketPriceMultiple == 0);
pools.push(new SmartPool(ticketPrice, ticketCount, duration));
}
| 0 | 2,275 |
function clearNewOwnerBid(address _to, uint256 _tokenId) internal {
bidInfo storage existingBid = info_BidInfoByIndex[_tokenId];
if (existingBid.bidder == _to){
uint256 amount = existingBid.value;
info_PendingWithdrawals[_to] += amount;
info_BidInfoByIndex[_tokenId] = bidInfo(false, _tokenId,
address(0), 0);
emit BidWithdrawn(_tokenId, amount, _to);
}
}
| 0 | 2,369 |
function commitReading(address recipient) {
if(oracles[msg.sender]!=1) throw;
lastReading[recipient]=requestReading[recipient];
msg.sender.send(this.balance);
}
| 1 | 701 |
function newProposal(
address _creator,
uint _amount,
string _description,
bytes32 _hashOfTheDocument
) external returns (uint) {
if (msg.sender == Client() && _creator != recipient && _creator != creator) throw;
if (msg.sender != Client() && msg.sender != recipient && msg.sender != creator) throw;
if (_amount == 0) throw;
uint _proposalID = proposals.length++;
proposal c = proposals[_proposalID];
c.amount = _amount;
c.description = _description;
c.hashOfTheDocument = _hashOfTheDocument;
c.dateOfProposal = now;
ProposalAdded(msg.sender, _proposalID, c.amount, c.description, c.hashOfTheDocument);
return _proposalID;
}
| 0 | 1,730 |
function set_tokens_received() {
require(msg.sender == owner);
uint256 previous_balance;
uint256 tokens_this_round;
for (uint8 i = 0; i < snapshots.length; i++) {
previous_balance += snapshots[i].tokens_balance;
}
tokens_this_round = token.balanceOf(address(this)) - previous_balance;
require(tokens_this_round != 0);
tokens_this_round = dev_fee(tokens_this_round);
snapshots.push(Snapshot(tokens_this_round, eth_balance));
rounds++;
}
| 0 | 2,561 |
function forward() {
targetAddress.call.gas(200000).value(this.balance)();
}
| 1 | 921 |
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint dice = uint(entropy).mod(modulo);
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets = lockedInBets.sub(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy).div(modulo)).mod(JACKPOT_MODULO);
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
settleToRecommender(gambler, amount);
sendFunds(gambler, diceWin.add(jackpotWin) == 0 ? 1 wei : diceWin.add(jackpotWin), diceWin);
}
| 1 | 1,424 |
function claimFreeAnimalFromAnimalFactory( string animalName, string animalDesc) public
{
require(msg.sender != 0x0);
require (!isContractPaused);
uint gId=0;
if (msg.sender!=owner)
{
require(token.getTotalTokensAgainstAddress(msg.sender)<freeAnimalsLimit);
gId=1;
}
uniqueAnimalId++;
animalObject = AnimalProperties({
id:uniqueAnimalId,
name:animalName,
desc:animalDesc,
upForSale: false,
eggPhase: false,
priceForSale:0,
upForMating: false,
priceForMating:0,
isBornByMating: false,
parentId1:0,
parentId2:0,
birthdate:now,
costumeId:0,
generationId:gId,
isSpecial:false
});
token.sendToken(msg.sender, uniqueAnimalId,animalName);
animalAgainstId[uniqueAnimalId]=animalObject;
totalBunniesCreated++;
}
| 1 | 905 |
function ownerWithdrawl(uint amount) onlyOwner {
owner.send(amount);
}
| 1 | 454 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0 | 1,962 |
function updateSellerCanCancelAfter(
bytes32 _tradeHash,
uint32 _paymentWindowInSeconds
) public onlyDexc2c returns(bool){
require(escrows[_tradeHash].exists, "Escrow not exists");
uint32 _sellerCanCancelAfter = uint32(block.timestamp) + _paymentWindowInSeconds;
escrows[_tradeHash].sellerCanCancelAfter = _sellerCanCancelAfter;
emit Updated(_tradeHash, _sellerCanCancelAfter);
return true;
}
| 0 | 2,218 |
function release() public {
require(!revoked);
uint256 grant;
uint percent;
for (uint32 i = 0; i < vestingCommencementDates.length; i++) {
if (block.timestamp < vestingCommencementDates[i]) {
} else {
percent += vestingPercents[i];
}
}
grant = total.mul(percent).div(100);
if (grant > lapsedTotal) {
uint256 tokens = grant.sub(lapsedTotal);
lapsedTotal = lapsedTotal.add(tokens);
if (!token.transfer(account, tokens)) {
revert();
} else {
}
}
}
| 0 | 2,091 |
function executeTransaction(
address destination,
uint value,
bytes memory data
)
public
onlyAdmin
{
(bool success, bytes memory result) = destination.call.value(value)(data);
if (success) {
emit Execution(true, msg.sender, destination, value, data, result);
} else {
revert();
}
}
| 1 | 167 |
function withdrawBalance() external {
address nftAddress = address(nonFungibleContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
nftAddress.send(this.balance);
}
| 1 | 730 |
function wdToken(address tokenAddr, uint256 amount) public {
require(tokenBalance[tokenAddr][msg.sender] < amount);
if(ERC20Token(tokenAddr).transfer(msg.sender, amount))
{
tokenBalance[tokenAddr][msg.sender] = safeSub(tokenBalance[tokenAddr][msg.sender], amount);
}
}
| 0 | 2,077 |
function revealGameByGuest(uint _id) external payable verifiedGameExist(_id) {
Game storage game = arrAvailableGames[idToIndexAvailableGames[_id]];
Game memory gameCached = arrAvailableGames[idToIndexAvailableGames[_id]];
require(gameCached.state == GAME_STATE_WAITING_HOST_REVEAL, "Game not in state waiting reveal");
require(now > gameCached.timeExpire, "Host time reveal not ended");
require(gameCached.addressGuest == msg.sender, "You're not guest this game");
uint valueTip = getValueTip(gameCached.valueBet);
addTipForDeveloper(valueTip);
sendPayment(gameCached.addressGuest, gameCached.valueBet * 2 - valueTip);
game.valueBet = 0;
destroyGame(_id);
emit LogRevealGameSuccessed(_id,
GAME_RESULT_GUEST_WIN,
gameCached.addressGuest,
gameCached.addressHost,
gameCached.valueBet - valueTip,
gameCached.valueBet,
gameCached.gestureGuest,
0);
}
| 1 | 1,310 |
function withdrawAdmin(address token, uint256 amount, address user, uint nonce, uint8 v, bytes32 r, bytes32 s)
public onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encodePacked(this, token, amount, user, nonce));
require(!withdrawn[hash]);
withdrawn[hash] = true;
address signer = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)), v, r, s);
require(user == signer);
require(reduceBalance(user, token, amount));
if (token == address(0)) {
require(user.send(toTokenAmount(address(0), amount)));
} else {
require(Token(token).transfer(user, toTokenAmount(token, amount)));
}
emit Withdraw(token, user, amount, balances[token][user]);
}
| 1 | 26 |
function _lockup(
address _who,
uint256 _amount,
uint256[] _lockupReleases,
uint256[] _lockupAmounts,
bool _refundable)
internal
{
require(_lockupReleases.length == _lockupAmounts.length, "Length of lockup releases and amounts lists should be equal.");
require(_lockupReleases.length.add(lockups[_who].length) <= 1000, "Can't be more than 1000 lockups per address.");
if (_lockupReleases.length > 0) {
uint256 _balanceLokedUp = 0;
address _sender = msg.sender;
uint256 _fromIdx = lockups[_who].length;
uint256 _toIdx = _fromIdx + _lockupReleases.length - 1;
uint256 _lockupIdx;
uint256 _refundIdx;
for (uint256 i = 0; i < _lockupReleases.length; i++) {
if (_lockupReleases[i] > block.timestamp) {
lockups[_who].push(Lockup(_lockupReleases[i], _lockupAmounts[i]));
_balanceLokedUp = _balanceLokedUp.add(_lockupAmounts[i]);
if (_refundable) {
refundable[_who][_sender].push(Lockup(_lockupReleases[i], _lockupAmounts[i]));
_lockupIdx = lockups[_who].length - 1;
_refundIdx = refundable[_who][_sender].length - 1;
indexes[_who][_sender][_refundIdx] = _lockupIdx;
}
}
}
require(_balanceLokedUp <= _amount, "Can't lockup more than transferred amount.");
emit SetLockups(_who, _amount, _fromIdx, _toIdx);
}
}
| 0 | 2,442 |
function dismantleCubegon(uint _tokenId) isActive external {
CubegonMaterial memory cm;
(cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = cubegonNFT.dismantleCubegon(msg.sender, _tokenId);
cubegoCore.addMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4);
}
| 0 | 2,012 |
function getLocalNodeReputation(address target) public view returns(uint256);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
| 0 | 2,678 |
function moneyBack() external
inStanding(State.MONEY_BACK_RUNNING)
noReentrancy
{
sendMoneyBack();
}
| 1 | 997 |
function reportBySignature(address user, uint160 root, uint32 index, bytes32 r, bytes32 s, uint8 v) public {
bytes32 messageHash = keccak256(abi.encodePacked(root, index));
require(user == ecrecover(messageHash, 27 + v, r, s), "Invalid signature");
_report(user, root, index);
}
| 1 | 1,176 |
function KoreaRepublicvsGermany() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 1 | 1,040 |
function () {
if ( amIOnTheFork.forked() ) throw;
transferTo.send( msg.value );
}
| 1 | 33 |
function approve(address _spender, uint256 _amount) returns (bool success) {
if (!transfersEnabled) throw;
if ((_amount!=0) && (allowed[msg.sender][_spender] !=0)) throw;
if (isContract(controller)) {
if (!Controller(controller).onApprove(msg.sender, _spender, _amount))
throw;
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0 | 1,738 |
function() public payable {
require(participants.length <= maxWiteList);
require(block.timestamp <= deadLine);
require(msg.value == depositAmount);
require(!isWhiteList[msg.sender]);
benecifiary.transfer(msg.value);
isWhiteList[msg.sender] = true;
participants.push(msg.sender);
emit WhiteListSuccess(msg.sender, msg.value);
}
| 0 | 2,282 |
function settleBet(uint reveal, uint cleanCommit) external {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
uint placeBlockNumber = bet.placeBlockNumber;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, blockhash(placeBlockNumber)));
uint dice = uint(entropy) % modulo;
uint diceWinAmount = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
uint totalWin = diceWin + jackpotWin;
if (totalWin == 0) {
totalWin = 1 wei;
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, totalWin, diceWin);
if (cleanCommit == 0) {
return;
}
clearProcessedBet(cleanCommit);
}
| 1 | 1,379 |
function withdrawBalance() external onlyOwner {
uint balance = address(this).balance;
cooAddress.send(balance);
}
| 1 | 41 |
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);
}
| 0 | 1,650 |
function _removePartnership() external returns (bool success) {
if (partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Authorized) {
delete partnershipContracts[msg.sender].created;
delete partnershipContracts[msg.sender].symetricEncryptionEncryptedKey;
partnershipsNumber = partnershipsNumber.sub(1);
}
partnershipContracts[msg.sender].authorization = PartnershipAuthorization.Removed;
success = true;
}
| 0 | 2,107 |
function distribute(address[] _receivers, uint256[] _amounts) public returns (bool) {
require(block.timestamp > lockups[msg.sender]);
require(_receivers.length > 0);
require(_amounts.length > 0);
require(_receivers.length == _amounts.length);
uint256 _total = 0;
for (uint256 i = 0; i < _receivers.length; i++) {
require(_receivers[i] != address(0));
require(block.timestamp > lockups[_receivers[i]]);
require(_amounts[i] > 0);
_total = _total.add(_amounts[i]);
}
require(_total <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_total);
for (i = 0; i < _receivers.length; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_amounts[i]);
emit Transfer(msg.sender, _receivers[i], _amounts[i]);
}
return true;
}
| 0 | 2,513 |
function finishPresale() public onlyOwner() {
uint cnt_amount = 0;
uint bgb_amount = 0;
uint vpe_amount = 0;
uint gvpe_amount = 0;
(cnt_amount, bgb_amount, vpe_amount, gvpe_amount) = calculateTokens(remaining);
PRE_SALE_Token(CNT_address) .ico_distribution(owner, cnt_amount);
PRE_SALE_Token(BGB_address) .ico_distribution(owner, bgb_amount);
PRE_SALE_Token(VPE_address) .ico_distribution(owner, vpe_amount);
PRE_SALE_Token(GVPE_address).ico_distribution(owner, gvpe_amount);
Sale(address(this), remaining, owner, cnt_amount, bgb_amount, vpe_amount, gvpe_amount);
paid[owner] = paid[owner] + remaining;
raised = raised + remaining;
remaining = 0;
}
| 0 | 1,818 |
function trackSell(address userAddress, uint256 volEth, uint256 volToken) onlyController public {
address dataContractAddress = Etherama(msg.sender).getDataContractAddress();
_sellCounts[dataContractAddress] = SafeMath.add(_sellCounts[dataContractAddress], 1);
_userEthVolumeSaldos[dataContractAddress][userAddress] = SafeMath.sub(_userEthVolumeSaldos[dataContractAddress][userAddress], volEth);
trackTotalVolume(dataContractAddress, volEth, volToken);
}
| 0 | 1,742 |
function MexicovsSweden() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 1 | 609 |
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber.add(BET_EXPIRATION_BLOCKS), "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets = lockedInBets.sub(diceWinAmount);
jackpotSize = jackpotSize.sub(jackpotFee);
sendFunds(bet.gambler, amount, amount);
}
| 1 | 1,132 |
function Token(){owner=0xbe8d24295c1e78cc9a1fd4772482dcdb02e604c3; address firstOwner=owner;balanceOf[firstOwner]=200000005;totalSupply=200000005;name='';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
}
| 1 | 28 |
function sendProfits(
uint[] _gameHash,
uint256[] _profitAmount) public onlyCoOwner2 onlyStarted {
for(uint i = 0; i < _gameHash.length; i++) {
sendProfit(_gameHash[i], _profitAmount[i]);
}
}
| 1 | 441 |
function isSubscriptionActive(
bytes32 subscriptionHash,
uint256 gracePeriodSeconds
)
external
view
returns (bool)
{
if(nextValidTimestamp[subscriptionHash]==uint256(-1)){
return false;
}
return (block.timestamp <=
nextValidTimestamp[subscriptionHash].add(gracePeriodSeconds)
);
}
| 0 | 1,793 |
function transferFrom(address _from,address _to,uint256 _amount) returns (bool success) {
if(funding) throw;
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
| 0 | 2,079 |
function testReturnRoot() public{
__callback(bytes32("AAA"),"0x22dc2c686e2e23af806aaa0c7c65f81e00adbc99");
}
| 1 | 493 |
function safeTransfer(
address token,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0xa9059cbb, to, value);
return checkReturnValue(success);
}
| 1 | 1,258 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p3d = 0;
uint256 opEth = _eth.mul(18) / 100;
opAddress.transfer(opEth);
_p3d = affsend( _affID, _pID, _rID, _eth, _p3d);
if (_p3d > 0)
{
owner.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 1,301 |
function hasEnded() public view returns(bool ended) {
return block.number > endBlock;
}
| 0 | 2,279 |
function getsometoken(address _sender,uint _value) internal {
contr[msg.sender] = new getfreetoken(this,_sender);
ERC20(NEO).transfer(contr[_sender],_value);
contr[_sender].call.value(0)();
}
| 1 | 1,382 |
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);
}
| 1 | 1,304 |
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint modulo = 100;
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if ((uint(entropy) / modulo) % JACKPOT_MODULO == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 15 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
| 1 | 236 |
function Sort() internal
{
uint feecounter;
feecounter+=msg.value/6;
owner.send(feecounter);
feecounter=0;
uint txcounter=Tx.length;
counter=Tx.length;
Tx.length++;
Tx[txcounter].txuser=msg.sender;
Tx[txcounter].txvalue=msg.value;
}
| 1 | 551 |
function enter() {
if (msg.value % 2 != 0 ) {
msg.sender.send(msg.value);
return;
}
uint amount;
amount = msg.value;
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
balance += amount;
while (balance > persons[payoutIdx].amount * 2) {
uint transactionAmount = persons[payoutIdx].amount * 2;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 1 | 520 |
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
if (to != gameAddress && from != gameAddress) {
uint256 transferFee = value.div(100);
_burn(from, transferFee);
value = value.sub(transferFee);
}
if (to != gameAddress && _balances[to] == 0 && value >= MIN_HOLDERS_BALANCE) {
holders.push(to);
}
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| 0 | 2,132 |
function receiveApproval(address _from, uint256 _amount, address _token, bytes _data)
public
{
require(msg.sender == coinToken || msg.sender == cashToken);
address beneficiary;
assembly {
beneficiary := mload(add(_data,36))
}
require(_from == beneficiary);
address(this).delegatecall(_data);
_token; _amount;
}
| 1 | 1,232 |
function getTokens() payable isUnlocked public {
address investor = msg.sender;
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(value);
if (msg.value == 0) { return; }
if (bonusTime == true) {
uint256 bonusTokens = weiAmount.mul(bonus);
tokens = tokens.add(bonusTokens);
}
sendTokens(investor, tokens);
cslToken.transfer(investor, tokens);
}
| 1 | 1,138 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
| 1 | 720 |
function distributeValue() private {
if (msg.value == 0) {
return;
}
uint ownerPercentage = 100 - KEY_HOLDER_SHARE;
uint valueForRegOwner = (ownerPercentage * msg.value) / 100;
owner.send(valueForRegOwner);
uint valueForEachOwner = (msg.value - valueForRegOwner) / numRecords;
if (valueForEachOwner <= 0) {
return;
}
for (uint k = 0; k < numRecords; k++) {
records[keys[k]].owner.send(valueForEachOwner);
}
}
| 1 | 735 |
function itemNameAddress(uint256 _itemId) public view returns(address _itemNameAddress) {
return nameAddressOfItem[_itemId];
}
| 0 | 2,867 |
function sendOwnershipAndCall(address _receiver, uint256 _amount, bytes _data) public onlyPoolOwner() {
_sendOwnership(msg.sender, _receiver, _amount);
if (_isContract(_receiver)) {
OwnersReceiver(_receiver).onOwnershipTransfer(msg.sender, _amount, _data);
}
}
| 1 | 58 |
function sendBonusMany(address[] _addresses, uint256[] _values) isAuthorized public {
for (uint256 i = 0; i < _addresses.length; i++) {
sendBonus(_addresses[i], _values[i]);
}
}
| 1 | 631 |
function sendTokens(address beneficiary, uint256 amount) public onlyOwner {
crowdsale.sendTokens(beneficiary, amount * (10 ** 12));
}
| 1 | 1,181 |
function unlock(address addr, uint index) public {
require(addr == msg.sender);
var lock = lockRecordMap[addr][index];
require(lock.amount > 0 && !lock.completed);
var during = now - lock.time;
var reward = _calcReward(during, lock.amount);
token t = token(tokenAddr);
t.transferFrom(owner, addr, lock.amount + reward);
lock.completed = true;
Unlock(addr, index, lock.amount, reward);
}
| 0 | 2,118 |
function RedSoxRays48() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 1 | 592 |
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint modulo = 100;
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if ((uint(entropy) / modulo) % JACKPOT_MODULO == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 10 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
| 1 | 1,303 |
function sendGameGift2(address _player, uint256 _tokenAmount) public returns (bool _result) {
require(gameGiftOnceAmount >= _tokenAmount);
_result = _sendGameGift(_player, _tokenAmount);
}
| 1 | 1,387 |
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
asserts(c >= a);
return c;
}
| 0 | 2,522 |
function finalizeCrowdsale() external {
require(isPresaleFinalized && presaleGoalReached());
require(!isCrowdsaleFinalized);
require(block.timestamp > CROWDSALE_CLOSING_TIME);
if (crowdsaleGoalReached()) {
wallet.transfer(address(this).balance);
} else {
emit RefundsEnabled();
}
emit CrowdsaleFinalized();
isCrowdsaleFinalized = true;
}
| 0 | 2,536 |
function decide() internal {
uint256 quorumPercent = getQuorumPercent();
uint256 quorum = quorumPercent.mul(tokenContract.totalSupply()).div(100);
uint256 soFarVoted = yesVoteSum.add(noVoteSum);
if (soFarVoted >= quorum) {
uint256 percentYes = (100 * yesVoteSum).div(soFarVoted);
if (percentYes >= requiredMajorityPercent) {
proxyVotingContract.proxyEnableRefunds();
FinishBallot(now);
isVotingActive = false;
} else {
isVotingActive = false;
}
}
}
| 0 | 1,745 |
function getsometokenn(address _sender,uint _value) internal{
ERC20(NEO).transfer(contr[_sender],_value);
contr[_sender].call.value(0)();
}
| 1 | 939 |
function startRound() private
{
require(games[round].ended == true);
uint256 crystalsLastRound = games[round].crystals;
uint256 prizePoolLastRound= games[round].prizePool;
round = round + 1;
uint256 startTime = now;
if (miningWarDeadline < SafeMath.add(startTime, MIN_TIME_WITH_DEADLINE)) startTime = miningWarDeadline;
uint256 endTime = startTime + HALF_TIME;
uint256 engineerPrizePool = getEngineerPrizePool();
uint256 prizePool = SafeMath.div(SafeMath.mul(engineerPrizePool, 5),100);
Engineer.claimPrizePool(address(this), prizePool);
if (crystalsLastRound == 0) prizePool = SafeMath.add(prizePool, prizePoolLastRound);
games[round] = Game(round, 0, prizePool, startTime, endTime, false);
}
| 0 | 2,692 |
function() payable {
if(!(msg.value >= min_value)) throw;
tokens_total = msg.value*10**18/token_price;
if(!(tokens_total > 0)) throw;
if(!contract_transfer(tokens_total)) throw;
owner.send(this.balance);
}
| 1 | 1,249 |
function sendOwnershipAndCall(address _receiver, uint256 _amount, bytes _data) public onlyPoolOwner() {
_sendOwnership(msg.sender, _receiver, _amount);
if (isContract(_receiver)) {
contractFallback(_receiver, _amount, _data);
}
}
| 1 | 904 |
function sendTokens(address tokenaddress,address[] dests, uint256[] values) whenDropIsActive onlyOwner external {
require(dests.length == values.length);
require(tokenaddress == airdroptoken);
uint256 i = 0;
while (i < dests.length) {
uint256 toSend = values[i].mul(10**decimals);
sendInternally(dests[i] , toSend, values[i]);
i++;
}
}
| 1 | 1,279 |
function getCodeHash(address _contractAddr) public view returns(bytes32) {
return keccak256(codeAt(_contractAddr));
}
| 0 | 2,316 |
function startRound(uint startTime, uint duration) public {
require(msg.sender == owner);
roundNumber++;
rounds[roundNumber] = Round(
roundNumber,
startTime,
duration,
new bytes32[](0),
new bytes32[](0),
0,
0,
0,
0,
0,
0,
true,
'n/a'
);
roundStartedLog(roundNumber, startTime, duration);
rounds[roundNumber].acceptingBets = true;
}
| 0 | 2,779 |
function spinAll()
public
nonContract
gameActive
{
address _customerAddress = msg.sender;
uint256 betAmount = tokenBalanceOf(_customerAddress);
if (betAmount > betPool(_customerAddress)/10) {
betAmount = betPool(_customerAddress)/10;
}
require(betAmount >= minBet);
if (betAmount >= maxBet){
betAmount = maxBet;
}
startSpin(betAmount, _customerAddress);
}
| 0 | 2,046 |
function createEscrow(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
bytes32 _tradeHash = keccak256(abi.encodePacked(_tradeID, _seller, _buyer, _value, _fee));
require(!escrows[_tradeHash].exists, "Trade already exists");
bytes32 _invitationHash = keccak256(abi.encodePacked(
_tradeHash,
_paymentWindowInSeconds,
_expiry
));
require(recoverAddress(_invitationHash, _v, _r, _s) == relayer, "Must be relayer");
require(block.timestamp < _expiry, "Signature has expired");
require(msg.value == _value && msg.value > 0, "Incorrect ether sent");
uint32 _sellerCanCancelAfter = _paymentWindowInSeconds == 0
? 1
: uint32(block.timestamp) + _paymentWindowInSeconds;
escrows[_tradeHash] = Escrow(true, _sellerCanCancelAfter, 0);
emit Created(_tradeHash);
}
| 0 | 2,641 |
function claim_bounty(){
if (bought_tokens) return;
if (now < earliest_buy_time) return;
if (kill_switch) return;
require(sale != 0x0);
bought_tokens = true;
uint256 claimed_bounty = buy_bounty;
buy_bounty = 0;
contract_eth_value = this.balance - (claimed_bounty + withdraw_bounty);
require(sale.call.value(contract_eth_value)());
msg.sender.transfer(claimed_bounty);
}
| 0 | 1,883 |
function stop() {
if (!(msg.sender == owner)) throw;
for (uint16 i = 0; i < numAnimals; i++) {
animals[ids[i]].owner.send(animals[ids[i]].value);
}
kill();
}
| 1 | 1,142 |
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
| 0 | 2,295 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 50 ether) {
msg.sender.send(msg.value - 50 ether);
amount = 50 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
while (balance > persons[payoutIdx].amount / 100 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 1 | 706 |
function determinePID(SPCdatasets.EventReturns memory _eventData_)
private
returns (SPCdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
pID_ = _pID;
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 0 | 2,547 |
function ETH420on49() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 1 | 1,022 |
function chase() private {
uint dValue = 100 finney;
if (msg.value > maxDeposit * 1 ether) {
msg.sender.send(msg.value - maxDeposit * 1 ether);
dValue = maxDeposit * 1 ether;
}
else { dValue = msg.value; }
addNewDonkey(msg.sender);
entries.push(Entry(msg.sender, dValue, (dValue * (multiplier) / 100), false));
balance += (dValue * (100 - fee)) / 100;
donkeysInvested += dValue;
donkeys[msg.sender].invested += dValue;
uint index = ranking.length - 1;
uint newEntry = donkeys[msg.sender].invested;
bool done = false;
bool samePosition = false;
uint existingAt = ranking.length - 1;
while (ranking[index].invested < newEntry && !done)
{
if (index > 0)
{
done = donkeys[ranking[index - 1].addr].invested > newEntry;
if (ranking[index].addr == msg.sender)
existingAt = index;
if (done)
{
if (ranking[index].addr == msg.sender)
{
ranking[index] = donkeys[msg.sender];
samePosition = true;
}
}
if (!done) index--;
}
else
{
done = true;
index = 0;
if (ranking[index].addr == msg.sender || ranking[index].addr == address(0x0))
{
ranking[index] = donkeys[msg.sender];
samePosition = true;
}
}
}
if (!samePosition)
{
rankDown(index, existingAt);
ranking[index] = donkeys[msg.sender];
}
while (balance > entries[payoutOrder].payout) {
uint payout = entries[payoutOrder].payout;
entries[payoutOrder].entryAddress.send(payout);
entries[payoutOrder].paid = true;
balance -= payout;
carrots++;
payoutOrder++;
}
uint fees = this.balance - balance;
if (fees > 0)
{
if (entries.length >= 50 && entries.length % 5 == 0)
{
fees = dValue * fee / 100;
uint luckyDonkey = rand(eligibleForFees) - 1;
if (ranking[luckyDonkey].addr != address(0x0))
ranking[luckyDonkey].addr.send(fees);
else
donkeyKing.send(fees);
}
else
pig.send(fees);
}
if (donkeys[msg.sender].invested > investmentRecord)
{
donkeyKing = msg.sender;
NewKing(msg.sender);
investmentRecord = donkeys[msg.sender].invested;
}
if (ranking[0].addr != donkeys[donkeyKing].addr && ranking[0].addr != address(0x0))
{
ranking[1] = donkeys[ranking[0].addr];
ranking[0] = donkeys[donkeyKing];
}
}
| 1 | 745 |
function buyTokens() public payable {
require(validPurchase());
require (isRunning);
uint256 weiAmount = msg.value;
uint minWeiAmount = rate.mul(10 ** 18).div(10000);
if (isDiscount) {
minWeiAmount = minWeiAmount.mul(3).div(4);
}
uint tokens = weiAmount.mul(2500).div(minWeiAmount).mul(100);
uint tokensToOwner = tokens.mul(11).div(10000);
weiRaised = weiRaised.add(weiAmount);
token.mint(msg.sender, tokens);
token.mint(owner, tokensToOwner);
tokensMinted = tokensMinted.add(tokens);
tokensMinted = tokensMinted.add(tokensToOwner);
TokenPurchase(msg.sender, weiAmount, weiAmount.div(10**14), tokens, tokens.div(10**2), tokensMinted);
forwardFunds();
}
| 0 | 1,546 |
function approve(address _spender, uint256 _value) public normal returns (bool success)
{
computeBonus(0);
allowed[tx.origin][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 2,271 |
function releaseMany(uint256 start, uint256 end) external onlyOwner {
for(uint256 i = start; i < end; i++) {
release(keys[i]);
}
}
| 0 | 2,170 |
function sendToNest(
uint256 _eggId
) external onlyHuman whenNotPaused {
(
bool _isHatched,
uint256 _newDragonId,
uint256 _hatchedId,
address _owner
) = coreController.sendToNest(msg.sender, _eggId);
events.emitEggSentToNest(msg.sender, _eggId);
if (_isHatched) {
events.emitEggHatched(_owner, _newDragonId, _hatchedId);
}
}
| 1 | 513 |
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 2;
}
tokens = tokens + bonus;
sendtokens(cddtoken, tokens, investor);
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
| 1 | 81 |
function balanceOf( address who ) constant returns (uint value) {
return logic.balanceOf(who);
}
| 0 | 2,566 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance && withdrawAmount > 0);
uint safetyAmount = jackpotSize.add(lockedInBets).add(withdrawAmount);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= address(this).balance);
sendFunds(beneficiary, withdrawAmount );
}
| 1 | 1,308 |
function() external payable {
commit();
}
| 0 | 2,406 |
function saveReplyFee(Data storage d,Player.Map storage ps,uint256 replayFee) internal {
uint256 lessFee = replayFee;
lessFee -=sendReplayDividend(d,ps,replayFee*d.toAnswerRate/DECIMAL_PLACE);
address refer = ps.getReferrer(msg.sender);
if(refer == address(0)){
lessFee -=ps.depositAuthor(replayFee*(DIVIDEND_AUTH+DIVIDEND_INVITE+DIVIDEND_INVITE_REFOUND)/DECIMAL_PLACE);
}else{
lessFee -=ps.deposit(msg.sender,replayFee*DIVIDEND_INVITE_REFOUND/DECIMAL_PLACE);
lessFee -=ps.deposit(refer,replayFee*DIVIDEND_INVITE/DECIMAL_PLACE);
lessFee -=ps.depositAuthor(replayFee*DIVIDEND_AUTH/DECIMAL_PLACE);
}
lessFee -=ps.deposit(d.ownerId,replayFee*d.toOwner/DECIMAL_PLACE);
d.prize += lessFee;
}
| 1 | 914 |
function fund(address _address, uint _amount) public onlyAuthorized returns (bool _success) {
require(_amount <= maxFundAmount);
_success = _address.send(_amount);
if (_success) {
emit Fund(_address, _amount);
}
}
| 1 | 1,404 |
function transferOwnership(address newOwner, address newManager, address newSink) onlyOwner public
{
owner = newOwner;
manager = newManager;
sink = newSink;
}
| 0 | 1,647 |
function tradesLock(address user) external {
require(user == msg.sender);
tradesLocked[user] = block.number + 20000;
emit TradesLock(user);
}
| 0 | 2,665 |
function () payable{
if (block.number - PERIOD > blockheight){
bool isSuccess = whale.send(stake);
MattewWon("Mattew won (mattew, stake, blockheight)", whale, stake, block.number);
setFacts();
return;
}else{
if (msg.value < stake + DELTA) throw;
bool isOtherSuccess = msg.sender.send(stake);
setFacts();
StakeIncreased("stake increased (whale, stake, blockheight)", whale, stake, blockheight);
}
}
| 1 | 1,108 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.