func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function claimRefund() external {
uint256 depositedValue = 0;
if (isCrowdsaleFinalized && !crowdsaleGoalReached()) {
require(crowdsaleDeposited[msg.sender] > 0);
depositedValue = crowdsaleDeposited[msg.sender];
crowdsaleDeposited[msg.sender] = 0;
} else if (isPresaleFinalized && !presaleGoalReached()) {
require(presaleDeposited[msg.sender] > 0);
depositedValue = presaleDeposited[msg.sender];
presaleDeposited[msg.sender] = 0;
}
require(depositedValue > 0);
msg.sender.transfer(depositedValue);
emit Refunded(msg.sender, depositedValue);
} | 1 | 1,946 |
function withdraw()
onlyNonOwner()
onlyDividendPositive()
public
{
require (msg.sender == tx.origin);
address customerAddress = msg.sender;
uint256 dividends = myDividends(false);
payoutsTo_[customerAddress] += int256(SafeMath.mul(dividends, magnitude));
dividends += referralBalances[customerAddress];
referralBalances[customerAddress] = 0;
customerAddress.transfer(dividends);
emit onWithdraw(customerAddress, dividends);
} | 0 | 2,829 |
function donate() payable returns (bool success) {
require(msg.value != 0);
balances[owner1] += msg.value/2;
balances[owner2] += msg.value - msg.value/2;
Donate(msg.sender, msg.value);
return true;
} | 1 | 568 |
function getPreRemainCoins() onlyOwner public {
uint preRemains = PRE_MAX_CAP - preCoinSentToEther;
Backer storage backer = preBackers[owner];
coin.transfer(owner, preRemains);
backer.coinSent = backer.coinSent.add(preRemains);
preCoinSentToEther = preCoinSentToEther.add(preRemains);
LogCoinsEmited(this ,preRemains);
LogReceivedETH(owner, preEtherReceived);
} | 0 | 5,201 |
function build(address owner) public returns (DSProxy proxy) {
proxy = factory.build(owner);
proxies[owner].push(proxy);
proxiesCount[owner] ++;
} | 0 | 4,714 |
function __callback(bytes32 _queryId, string _result, bytes _proof) public onlyOraclizeOr(getContract('FD.Emergency')) {
var (policyId, oraclizeTime) = FD_DB.getOraclizeCallback(_queryId);
LogOraclizeCallback(policyId, _queryId, _result, _proof);
var state = FD_DB.getPolicyState(policyId);
require(uint8(state) != 5);
bytes32 riskId = FD_DB.getRiskId(policyId);
var slResult = _result.toSlice();
if (bytes(_result).length == 0) {
if (FD_DB.checkTime(_queryId, riskId, 180 minutes)) {
LogPolicyManualPayout(policyId, "No Callback at +120 min");
return;
} else {
schedulePayoutOraclizeCall(policyId, riskId, oraclizeTime + 45 minutes);
}
} else {
slResult.find("\"".toSlice()).beyond("\"".toSlice());
slResult.until(slResult.copy().find("\"".toSlice()));
bytes1 status = bytes(slResult.toString())[0];
if (status == "C") {
payOut(policyId, 4, 0);
return;
} else if (status == "D") {
payOut(policyId, 5, 0);
return;
} else if (status != "L" && status != "A" && status != "C" && status != "D") {
LogPolicyManualPayout(policyId, "Unprocessable status");
return;
}
slResult = _result.toSlice();
bool arrived = slResult.contains("actualGateArrival".toSlice());
if (status == "A" || (status == "L" && !arrived)) {
if (FD_DB.checkTime(_queryId, riskId, 180 minutes)) {
LogPolicyManualPayout(policyId, "No arrival at +180 min");
} else {
schedulePayoutOraclizeCall(policyId, riskId, oraclizeTime + 45 minutes);
}
} else if (status == "L" && arrived) {
var aG = "\"arrivalGateDelayMinutes\": ".toSlice();
if (slResult.contains(aG)) {
slResult.find(aG).beyond(aG);
slResult.until(slResult.copy().find("\"".toSlice()).beyond("\"".toSlice()));
slResult.until(slResult.copy().find("\x7D".toSlice()));
slResult.until(slResult.copy().find(",".toSlice()));
uint delayInMinutes = parseInt(slResult.toString());
} else {
delayInMinutes = 0;
}
if (delayInMinutes < 15) {
payOut(policyId, 0, 0);
} else if (delayInMinutes < 30) {
payOut(policyId, 1, delayInMinutes);
} else if (delayInMinutes < 45) {
payOut(policyId, 2, delayInMinutes);
} else {
payOut(policyId, 3, delayInMinutes);
}
} else {
payOut(policyId, 0, 0);
}
} | 0 | 4,214 |
function getRateCentUsd() public view returns(uint) {
if (block.timestamp >= 1539550800 && block.timestamp < 1541019600) {
return(70);
}
if (block.timestamp >= 1541019600 && block.timestamp < 1545685200) {
return(100);
}
} | 1 | 139 |
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
amount = invested[sender] * interest / 100 * (now - dateInvest[sender]) / 1 days;
if (msg.value == 0) {
if (amount >= address(this).balance) {
amount = (address(this).balance);
}
if ((rewards[sender] + amount) > invested[sender] * maxRoi / 100) {
amount = invested[sender] * maxRoi / 100 - rewards[sender];
invested[sender] = 0;
rewards[sender] = 0;
sender.send(amount);
return;
} else {
sender.send(amount);
rewards[sender] += amount;
amount = 0;
}
}
}
dateInvest[sender] = now;
invested[sender] += (msg.value + amount);
if (msg.value != 0) {
WhaleAddr.send(msg.value * whalefee / 100);
if (invested[sender] > invested[WhaleAddr]) {
WhaleAddr = sender;
}
}
} | 0 | 2,607 |
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
} | 1 | 1,662 |
function stake(address _userUportAddress, uint _expiryDate, bytes _signature) public payable whenNotPaused {
bytes32 hashMessage = keccak256(abi.encodePacked(_userUportAddress, msg.value, _expiryDate));
address signer = hashMessage.toEthSignedMessageHash().recover(_signature);
require(signer == grantSigner, "Signature is not valid");
require(block.timestamp < _expiryDate, "Grant is expired");
require(userStakedAddress[_userUportAddress] == 0, "User has already staked!");
userStakedAddress[_userUportAddress] = msg.sender;
stakedAmount[_userUportAddress] = msg.value;
emit UserStake(_userUportAddress, msg.sender, msg.value);
} | 1 | 1,779 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, LOLdatasets.EventReturns memory _eventData_)
private
returns(LOLdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit LOLevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
address(lol_offical_bank).call.value(_com)(bytes4(keccak256("deposit()")));
return(_eventData_);
} | 1 | 463 |
function emitSynthetixUpdated(address newSynthetix) internal {
proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0);
} | 0 | 2,846 |
function mintTokens(address beneficiary, uint256 tokens) internal {
require(beneficiary != 0x0);
uint256 weiAmount;
if (block.timestamp >= time0 && block.timestamp < time1) weiAmount = tokens.mul(65).div(1000);
else if (block.timestamp >= time1 && block.timestamp < time2) weiAmount = tokens.mul(70).div(1000);
else if (block.timestamp >= time2 && block.timestamp < time3) weiAmount = tokens.mul(75).div(1000);
else if (block.timestamp >= time3 && block.timestamp < time4) weiAmount = tokens.mul(80).div(1000);
else if (block.timestamp >= time4 && block.timestamp < time5) weiAmount = tokens.mul(85).div(1000);
else if (block.timestamp >= time5 && block.timestamp < time6) weiAmount = tokens.mul(90).div(1000);
else if (block.timestamp >= time6 && block.timestamp < time7) weiAmount = tokens.mul(95).div(1000);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, block.timestamp);
} | 1 | 594 |
function was called.
uint256 currentTotalBankroll = getBankroll();
uint256 currentSupplyOfTokens = totalSupply;
uint256 withdrawEther = SafeMath.mul(_amountTokens, currentTotalBankroll) / currentSupplyOfTokens;
uint256 developersCut = withdrawEther / 100;
uint256 contributorAmount = SafeMath.sub(withdrawEther, developersCut);
totalSupply = SafeMath.sub(currentSupplyOfTokens, _amountTokens);
balances[msg.sender] = SafeMath.sub(tokenBalance, _amountTokens);
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
msg.sender.transfer(contributorAmount);
emit CashOut(msg.sender, contributorAmount, _amountTokens);
emit Transfer(msg.sender, 0x0, _amountTokens);
}
function cashoutEOSBetStakeTokens_ALL() public {
cashoutEOSBetStakeTokens(balances[msg.sender]);
}
function transferOwnership(address newOwner) public {
require(msg.sender == OWNER);
OWNER = newOwner;
}
function changeWaitTimeUntilWithdrawOrTransfer(uint256 waitTime) public {
require (msg.sender == OWNER && waitTime <= 6048000);
WAITTIMEUNTILWITHDRAWORTRANSFER = waitTime;
}
function changeMaximumInvestmentsAllowed(uint256 maxAmount) public {
require(msg.sender == OWNER);
MAXIMUMINVESTMENTSALLOWED = maxAmount;
}
function withdrawDevelopersFund(address receiver) public {
require(msg.sender == OWNER);
EOSBetGameInterface(DICE).payDevelopersFund(receiver);
EOSBetGameInterface(SLOTS).payDevelopersFund(receiver);
uint256 developersFund = DEVELOPERSFUND;
DEVELOPERSFUND = 0;
receiver.transfer(developersFund);
}
function ERC20Rescue(address tokenAddress, uint256 amtTokens) public {
require (msg.sender == OWNER);
ERC20(tokenAddress).transfer(msg.sender, amtTokens);
}
function totalSupply() constant public returns(uint){
return totalSupply;
}
function balanceOf(address _owner) constant public returns(uint){
return balances[_owner];
}
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;
}
function transferFrom(address _from, address _to, uint _value) public returns(bool){
require(allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& contributionTime[_from] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public returns(bool){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns(uint){
return allowed[_owner][_spender];
}
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
} | 1 | 2,357 |
function McFlyCrowd(
uint256 _startTimeTLP2,
uint256 _preMcFlyTotalSupply,
address _wallet,
address _wavesAgent,
address _wavesGW,
address _fundMintingAgent,
address _teamWallet,
address _bountyOnlineWallet,
address _bountyOnlineGW,
address _bountyOfflineWallet,
address _advisoryWallet,
address _reservedWallet,
address _airdropWallet,
address _airdropGW,
address _preMcFlyWallet
) public
{
require(_startTimeTLP2 >= block.timestamp);
require(_preMcFlyTotalSupply > 0);
require(_wallet != 0x0);
require(_wavesAgent != 0x0);
require(_wavesGW != 0x0);
require(_fundMintingAgent != 0x0);
require(_teamWallet != 0x0);
require(_bountyOnlineWallet != 0x0);
require(_bountyOnlineGW != 0x0);
require(_bountyOfflineWallet != 0x0);
require(_advisoryWallet != 0x0);
require(_reservedWallet != 0x0);
require(_airdropWallet != 0x0);
require(_airdropGW != 0x0);
require(_preMcFlyWallet != 0x0);
token = new McFlyToken();
wallet = _wallet;
sT2 = _startTimeTLP2;
setStartEndTimeTLP(_startTimeTLP2);
wavesAgent = _wavesAgent;
wavesGW = _wavesGW;
fundMintingAgent = _fundMintingAgent;
teamWallet = _teamWallet;
bountyOnlineWallet = _bountyOnlineWallet;
bountyOnlineGW = _bountyOnlineGW;
bountyOfflineWallet = _bountyOfflineWallet;
advisoryWallet = _advisoryWallet;
reservedWallet = _reservedWallet;
airdropWallet = _airdropWallet;
airdropGW = _airdropGW;
preMcFlyWallet = _preMcFlyWallet;
_preMcFlyTokens = _preMcFlyTotalSupply;
token.mint(preMcFlyWallet, _preMcFlyTokens);
token.allowTransfer(preMcFlyWallet);
crowdTokensTLP2 = crowdTokensTLP2.add(_preMcFlyTokens);
token.mint(wavesAgent, wavesTokens);
token.allowTransfer(wavesAgent);
token.allowTransfer(wavesGW);
crowdTokensTLP2 = crowdTokensTLP2.add(wavesTokens);
_teamTokens = 180e24;
token.mint(this, _teamTokens);
_bountyOnlineTokens = 36e24;
token.mint(bountyOnlineWallet, _bountyOnlineTokens);
token.allowTransfer(bountyOnlineWallet);
token.allowTransfer(bountyOnlineGW);
_bountyOfflineTokens = 54e24;
token.mint(bountyOfflineWallet, _bountyOfflineTokens);
token.allowTransfer(bountyOfflineWallet);
_advisoryTokens = 90e24;
token.mint(this, _advisoryTokens);
_reservedTokens = 162e24;
token.mint(this, _reservedTokens);
_airdropTokens = 18e24;
token.mint(airdropWallet, _airdropTokens);
token.allowTransfer(airdropWallet);
token.allowTransfer(airdropGW);
} | 1 | 450 |
function createLoan(Oracle _oracleContract, address _borrower, bytes32 _currency, uint256 _amount, uint256 _interestRate,
uint256 _interestRatePunitory, uint256 _duesIn, uint256 _cancelableAt, uint256 _expirationRequest, string _metadata) public returns (uint256) {
require(!deprecated);
require(_cancelableAt <= _duesIn);
require(_oracleContract != address(0) || _currency == 0x0);
require(_borrower != address(0));
require(_amount != 0);
require(_interestRatePunitory != 0);
require(_interestRate != 0);
require(_expirationRequest > block.timestamp);
var loan = Loan(Status.initial, _oracleContract, _borrower, 0x0, msg.sender, 0x0, _amount, 0, 0, 0, 0, _interestRate,
_interestRatePunitory, 0, _duesIn, _currency, _cancelableAt, 0, 0x0, _expirationRequest, _metadata);
uint index = loans.push(loan) - 1;
CreatedLoan(index, _borrower, msg.sender);
bytes32 identifier = getIdentifier(index);
require(identifierToIndex[identifier] == 0);
identifierToIndex[identifier] = index;
if (msg.sender == _borrower) {
approveLoan(index);
}
return index;
} | 1 | 1,730 |
function setTargetDiscountValue4 (uint newTargetDiscountValue4) public onlyOwner {
require(newTargetDiscountValue4 > 0);
targetDiscountValue4 = newTargetDiscountValue4;
} | 0 | 2,634 |
function sell(IERC20Token _connectorToken, uint256 _sellAmount, uint256 _minReturn) internal returns (uint256) {
require(_sellAmount <= token.balanceOf(msg.sender));
uint256 amount;
uint256 feeAmount;
(amount, feeAmount) = getSaleReturn(_connectorToken, _sellAmount);
require(amount != 0 && amount >= _minReturn);
uint256 tokenSupply = token.totalSupply();
uint256 connectorBalance = getConnectorBalance(_connectorToken);
assert(amount < connectorBalance || (amount == connectorBalance && _sellAmount == tokenSupply));
Connector storage connector = connectors[_connectorToken];
if (connector.isVirtualBalanceEnabled)
connector.virtualBalance = connector.virtualBalance.sub(amount);
token.destroy(msg.sender, _sellAmount);
ensureTransfer(_connectorToken, msg.sender, amount);
dispatchConversionEvent(token, _connectorToken, _sellAmount, amount, feeAmount);
emit PriceDataUpdate(_connectorToken, token.totalSupply(), getConnectorBalance(_connectorToken), connector.weight);
return amount;
} | 0 | 4,051 |
function setETHAssets(
address ETHAssets_
)
public
onlyOperator
{
require(
ETHAssets_ != address(0)
);
if(
ETHAssets_ == ETHAssets &&
candidateETHAssets != address(0)
) {
emit eCancelNominatingETHAssets(candidateETHAssets);
candidateETHAssets = address(0);
candidateTillETHAssets = 0;
} else if(
ETHAssets == address(0)
) {
ETHAssets = ETHAssets_;
} else if(
ETHAssets_ != candidateETHAssets &&
candidateTillETHAssets + 86400 * 7 < block.timestamp
) {
emit eNominatingETHAssets(ETHAssets_);
candidateETHAssets = ETHAssets_;
candidateTillETHAssets = block.timestamp + 86400 * 7;
} else if(
ETHAssets_ == candidateETHAssets &&
candidateTillETHAssets < block.timestamp
) {
emit eChangeETHAssets(ETHAssets, candidateETHAssets);
dismissTokenOperator(ETHAssets);
assignTokenOperator(candidateETHAssets);
ETHAssets = candidateETHAssets;
candidateETHAssets = address(0);
}
} | 1 | 1,945 |
function play(uint _gType,uint[] _bet) payable isHuman() public{
require(!gamePaused,'Game Pause');
require(msg.value >= minBetVal*_bet.length && msg.value <= maxBetVal*_bet.length,"value is incorrect" );
bool _ret=false;
uint _betAmount= msg.value /_bet.length;
uint _prize=0;
uint _winNo= uint(keccak256(abi.encodePacked(rndSeed,msg.sender,block.coinbase,block.timestamp, block.difficulty,block.gaslimit))) % 52 + 1;
rndSeed = keccak256(abi.encodePacked(msg.sender,block.timestamp,rndSeed, block.difficulty));
if(_gType==1){
if(_betAmount * odds['bs'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
if((_winNo >= 29 && _bet.contain(2)) || (_winNo <= 24 && _bet.contain(1))){
_ret=true;
_prize=(_betAmount * odds['bs']) / 1 ether;
}else if(_winNo>=25 && _winNo <=28 && _bet.contain(0)){
_ret=true;
_prize=(_betAmount * 12 ether) / 1 ether;
}
}
if(_gType==2 && _bet.contain(_winNo%4+1)){
if(_betAmount * odds['suit'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
_ret=true;
_prize=(_betAmount * odds['suit']) / 1 ether;
}
if(_gType==3 && _bet.contain((_winNo-1)/4+1)){
if(_betAmount * odds['num'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
_ret=true;
_prize=(_betAmount * odds['num']) / 1 ether;
}
if(_gType==4 && _bet.contain(_winNo)){
if(_betAmount * odds['nsuit'] / 1 ether >= address(this).balance/2){
revert("over max bet amount");
}
_ret=true;
_prize=(_betAmount * odds['nsuit']) / 1 ether;
}
if(_ret){
msg.sender.transfer(_prize);
}else{
jpBalance += (msg.value * jpPercent) / 100 ether;
}
uint tmpJackpot=0;
if(_betAmount >= jpMinBetAmount){
uint _jpNo= uint(keccak256(abi.encodePacked(rndSeed,msg.sender,block.coinbase,block.timestamp, block.difficulty,block.gaslimit))) % jpChance;
if(_jpNo==77 && jpBalance>jpMinPrize){
msg.sender.transfer(jpBalance);
emit JackpotPayment(guid,msg.sender,_betAmount,jpBalance);
tmpJackpot=jpBalance;
jpBalance=0;
}else{
tmpJackpot=0;
}
rndSeed = keccak256(abi.encodePacked(block.coinbase,msg.sender,block.timestamp, block.difficulty,rndSeed));
}
emit Bettings(guid,_gType,msg.sender,_bet,_ret,_winNo,msg.value,_prize,tmpJackpot);
guid+=1;
} | 1 | 1,726 |
function start( uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress ) public onlyManager() hasntStarted() hasntStopped() {
require(_fundingAddress != address(0));
require(_startTimestamp >= block.timestamp);
require(_endTimestamp > _startTimestamp);
duration = _endTimestamp - _startTimestamp;
require(duration >= MIN_CROWDSALE_TIME && duration <= MAX_CROWDSALE_TIME);
startTimestamp = _startTimestamp;
endTimestamp = _endTimestamp;
started = true;
emit CROWDSALE_START(_startTimestamp, _endTimestamp, _fundingAddress);
} | 1 | 2,025 |
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner == 0x0) revert();
owner = newOwner;
} | 0 | 2,881 |
function getOpGas() constant returns (uint _rm, uint _rf, uint _rw)
{
_rm = rmGas;
_rf = rfGas;
_rw = rwGas;
} | 1 | 451 |
function transferCollateral(uint dealID) public payable {
REPODeal storage deal = deals[dealID];
require(deal.state == 1);
require(block.number < deal.collateralUntil);
require(msg.sender == deal.lender);
uint payment = deal.collateralAmount + deal.lenderFee;
if (deal.collateral == 0) {
require(msg.value == payment);
require(deal.borrower.send(deal.collateralAmount));
require(owner.send(deal.lenderFee));
} else {
require(ERC20(deal.collateral).transferFrom(msg.sender, deal.borrower, deal.collateralAmount));
require(ERC20(deal.collateral).transferFrom(msg.sender, owner, deal.lenderFee));
}
sendGoods(deal.pledge, owner, deal.borrowerFee);
deal.state = 2;
CollateralTransfered(dealID);
} | 0 | 4,386 |
function startFreeGet() onlyOwner canDistr public returns (bool) {
endFreeGet = false;
return true;
} | 0 | 3,246 |
function doCrowdsaleMinting(address _destination, uint _tokensToMint) public {
require(msg.sender == crowdsaleContractAddress);
require(mintingState == state.crowdsaleMinting);
require(safeAdd(tokensAlreadyMinted, _tokensToMint) <= crowdsaleMintingCap);
MintableTokenInterface(tokenAddress).mint(_destination, _tokensToMint);
tokensAlreadyMinted = safeAdd(tokensAlreadyMinted, _tokensToMint);
} | 0 | 3,179 |
function () public payable {
require(isRunning());
require(tx.gasprice <= MAX_GAS_PRICE * 1000000000);
address member = msg.sender;
uint amount = msg.value;
if (now - jackpot.time >= JACKPOT_DURATION && jackpot.time > 0) {
send(member, amount);
if (!payouts()) {
return;
}
send(jackpot.lastMember, jackpot.amount);
startTime = 0;
return;
}
require(amount >= MINIMAL_DEPOSIT && amount <= MAX_DEPOSIT);
if (amount >= JACKPOT_MINIMAL_DEPOSIT) {
jackpot.lastMember = member;
jackpot.time = now;
}
deposits.push( Deposit(member, amount * calcMultiplier() / 100) );
totalInvested += amount;
jackpot.amount += amount * JACKPOT_PERCENTAGE / 10000;
send(PROMOTION_FUND, amount * PROMOTION_PERCENTAGE / 10000);
send(SUPPORT_FUND, amount * PAYROLL_PERCENTAGE / 10000);
payouts();
} | 0 | 3,518 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
} | 0 | 3,585 |
function addManyToWhitelist(address[] _beneficiaries) public onlyOwnerOrWhitelister {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
} | 0 | 5,106 |
function GetWin(uint _duelID) external {
_duel storage duel = Duels[_duelID];
require(duel.state == State.OnGoing);
require(duel.creator == msg.sender || duel.responder == msg.sender);
require(block.number > duel.blocknumber + 1);
duel.state = State.Closed;
uint duel_fee = 0;
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
if (blockhash(duel.blocknumber) == 0 || (block.number - duel.blocknumber) > 256) {
duel_fee = safePerc(duel.bet, fee);
duel.creator.transfer(safeSub(duel.bet, duel_fee));
duel.responder.transfer(safeSub(duel.bet, duel_fee));
reward[N] = safeAdd(reward[N], safeMul(2, duel_fee));
emit refundDuel(_duelID);
duelWinner[_duelID] = address(0);
} else {
uint hash = uint(keccak256(abi.encodePacked(blockhash(duel.blocknumber + 1), duel.creator, duel.responder, duel.bet)));
uint duel_bet_common = safeMul(2, duel.bet);
duel_fee = safePerc(duel_bet_common, fee);
uint _refFee = 0;
uint sum = safeSub(duel_bet_common, duel_fee);
address winner;
if (hash % 2 == 0) {
duel.creator.transfer(sum);
winner = duel.creator;
emit resultDuel(_duelID, duel.creator, sum);
} else {
duel.responder.transfer(sum);
winner = duel.responder;
emit resultDuel(_duelID, duel.responder, sum);
}
duelWinner[_duelID] = winner;
if (RefAddr[winner] != address(0)) {
_refFee = refUserFee;
rewardAddr[RefAddr[winner]] = safeAdd(rewardAddr[RefAddr[winner]], safePerc(duel_fee, _refFee));
}
if (duel.refID != 0) {
_refFee = safeSub(refGroupFee, _refFee);
rewardGroup[RefGroup[duel.refID]] = safeAdd(rewardGroup[RefGroup[duel.refID]], safePerc(duel_fee, _refFee));
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, refGroupFee)));
} else {
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, _refFee)));
}
}
} | 1 | 999 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract RaRaCoin is ERC20, Ownable, Pausable {
uint128 internal MONTH = 30 * 24 * 3600;
using SafeMath for uint256;
struct LockupInfo {
uint256 releaseTime;
uint256 termOfRound;
uint256 unlockAmountPerRound;
uint256 lockupBalance;
} | 0 | 3,351 |
function isHatchOnCooldown() public view returns(bool){
return lastHatch[msg.sender].add(hatchCooldown[msg.sender])<now;
} | 0 | 3,815 |
function getDocumentIdWithContentHash(string _documentContentSHA256) public view
returns (uint)
{
bytes32 documentContentSHA256Keccak256 = keccak256(_documentContentSHA256);
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (keccak256(doc.documentContentSHA256)==documentContentSHA256Keccak256) {
return i;
}
}
return 0;
} | 1 | 192 |
function MatchResetDeadline(uint index,uint time)
external
onlyOwner MatchExist(index) {
MatchBet storage oMatch = MatchList[index];
oMatch.betDeadline = time;
} | 0 | 4,993 |
function() payable {
if(msg.sender!=owner){
if(msg.value<100000000000000000||msg.value>1000000000000000000) throw;
if(address(this).balance < msg.value/100*prizes[0]) throw;
bytes32 oid = oraclize_query(queryType, query, oraclizeGas);
bets[oid] = msg.value;
players[oid] = msg.sender;
}
} | 0 | 4,354 |
function moneyBack() external
inStanding(State.MONEY_BACK_RUNNING)
noReentrancy
{
sendMoneyBack();
} | 0 | 4,395 |
constructor()
HasOwner(msg.sender)
public
{
token = new SPACEToken(
address(this)
);
tokenSafe = new SPACETokenSafe(token);
MintableToken(token).mint(address(tokenSafe), 315000000000000000000000);
initializeBasicFundraiser(
1543622400,
1564617540,
1,
0x413C7299268466e2E68A179750EBB7aC2d1D9160
);
initializeIndividualCapsFundraiser(
(0 ether),
(0 ether)
);
initializeGasPriceLimitFundraiser(
0
);
initializePresaleFundraiser(
900000000000000000000000,
1541030400,
1543622340,
1
);
} | 0 | 4,405 |
function BuyARXtokens() payable {
require(!(msg.value == 0)
&& (isPresaleSetup)
&& (block.number >= fundingStartBlock)
&& (block.number <= fundingEndBlock)
&& !(safeAdd(amountRaisedInWei,msg.value) > fundingMaxCapInWei));
uint256 rewardTransferAmount = 0;
setPrice();
amountRaisedInWei = safeAdd(amountRaisedInWei,msg.value);
rewardTransferAmount = safeMul(msg.value,tokensPerEthPrice);
fundingRemainingAvailableInEth = safeDiv(safeSub(fundingMaxCapInWei,amountRaisedInWei),1 ether);
tokenReward.transfer(msg.sender, rewardTransferAmount);
fundValue[msg.sender] = safeAdd(fundValue[msg.sender], msg.value);
Transfer(this, msg.sender, msg.value);
Buy(msg.sender, msg.value, rewardTransferAmount);
} | 0 | 4,610 |
function takeAll() public onlyOwner {
require(block.timestamp >= withdrawDelay);
msg.sender.transfer(jackpot);
jackpot = 0;
} | 1 | 2,194 |
function OodlebitToken(
) {
balances[msg.sender] = 200000000000000000000000000;
totalSupply = 200000000000000000000000000;
name = "OODL";
decimals = 18;
symbol = "OODL";
} | 0 | 5,029 |
function dispatch() onlyOwner mutex public {
for(uint i = 0; i < txs.length; i++) {
if (address(this).balance >= txs[i].value)
txs[i].user.send(txs[i].value);
}
} | 0 | 4,490 |
function getState() public constant returns (State) {
if (finalized) return State.Finalized;
else if (address(token) == 0 || address(multisigWallet) == 0 || block.timestamp < startsAt) return State.Preparing;
else if (block.timestamp <= endsAt && block.timestamp >= startsAt && !isCrowdsaleFull()) return State.Funding;
else if (isCrowdsaleFull()) return State.Success;
else return State.Failure;
} | 1 | 1,941 |
function _fight(uint32 _yinId, uint32 _yangId)
internal
whenNotPaused
returns(uint256)
{
Hero storage yin = heroes[_yinId];
require(yin.recruitmentTime != 0);
Hero storage yang = heroes[_yangId];
uint16 parentGen = yin.generation;
if (yang.generation > yin.generation) {
parentGen = yang.generation;
}
var (flag, childTalent, belongings1, belongings2) = masterRecruitment.fightMix(yin.belongings,yang.belongings);
yin.belongings = belongings1;
yang.belongings = belongings2;
if(!flag){
(_yinId,_yangId) = (_yangId,_yinId);
}
address owner = heroIndexToOwner[_yinId];
heroIndexToWin[_yinId] +=1;
heroIndexToLoss[_yangId] +=1;
uint256 newHeroId = _createHero(_yinId, _yangId, parentGen + 1, childTalent, owner);
_triggerCooldown(yang);
_triggerCooldown(yin);
return (newHeroId );
} | 0 | 3,780 |
function numBets()
view
public
returns(uint) {
return betsCount;
} | 0 | 4,367 |
function tileTimeoutTimestamp(uint256 identifier, address player) public view returns (uint256) {
uint256 bonusTime = gameSettings.timeoutBonusTime.mul(gameStates[gameIndex].addressToNumberOfTiles[player]);
uint256 timeoutTimestamp = block.timestamp.add(calculateBaseTimeout()).add(bonusTime);
uint256 currentTimeoutTimestamp = gameStates[gameIndex].identifierToTimeoutTimestamp[identifier];
if (currentTimeoutTimestamp == 0) {
currentTimeoutTimestamp = gameStates[gameIndex].gameStartTimestamp.add(gameSettings.initialActivityTimer);
}
if (timeoutTimestamp >= currentTimeoutTimestamp) {
return timeoutTimestamp;
} else {
return currentTimeoutTimestamp;
}
} | 1 | 2,451 |
function setBackendOwner(address _backendContract) onlyOwnerUnlocked {
backendContract = _backendContract;
} | 0 | 2,892 |
function setNextCycle() public onlyAdmin {
require(cycles.length > 0);
if (currentCycleNumber > 0) {
AgileCycleWithAssistance cycle = AgileCycleWithAssistance(currentCycleAddress);
uint finishedTimeStamp = cycle.finishedTimeStamp();
require(now > finishedTimeStamp);
uint interval = now - finishedTimeStamp;
}
currentCycleAddress = cycles[currentCycleNumber];
currentCycleNumber += 1;
} | 0 | 3,988 |
function read() external view returns (bytes32);
}
contract BZRxTokenSale is Ownable {
using SafeMath for uint256;
struct TokenPurchases {
uint totalETH;
uint totalTokens;
uint totalTokenBonus;
} | 0 | 4,996 |
function _escrow(address _owner, uint256 _tokenId) internal {
nonFungibleContract.transferFrom(_owner, this, _tokenId);
} | 0 | 3,187 |
function getSession(bytes32 superblockHash, address challenger) public view returns(bytes32) {
return claims[superblockHash].sessions[challenger];
} | 1 | 2,409 |
function buy(string promo) payable {
assert(now < preIcoEnd);
assert(now >= preIcoStart);
assert(msg.value>=minSizeInvest);
if(holders[msg.sender] == 0){
countHolders += 1;
}
holders[msg.sender] += msg.value;
amount_investments += msg.value;
Investment(msg.sender, msg.value);
if(affiliate != address(0x0)){
var (partner_address, partner_bonus, referral_bonus) = contractAffiliate.add_referral(msg.sender, promo, msg.value);
if(partner_bonus > 0 && partner_address != address(0x0)){
holdersBonus[partner_address] += msg.value;
amount_bonus += msg.value;
}
if(referral_bonus > 0){
holdersBonus[msg.sender] = referral_bonus;
amount_bonus += referral_bonus;
}
}
stopPreIco_step2();
} | 1 | 1,569 |
function payStakingFee(address payer, uint256 value, uint80 numerator, uint80 denominator, uint256 flatRate, address otherParticipant) private returns (uint256) {
if (noFeesList.onList(payer) || noFeesList.onList(otherParticipant)) {
return 0;
}
uint256 stakingFee = value.mul(numerator).div(denominator).add(flatRate);
if (stakingFee > 0) {
transferFromWithoutAllowance(payer, staker, stakingFee);
}
return stakingFee;
} | 0 | 3,698 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
require(currentStage < getStageCount());
uint256 value = msg.value;
weiRaised = weiRaised.add(value);
uint256 limit = getStageLimit(currentStage);
uint256 dif = 0;
uint256 returnToSender = 0;
if(weiRaised > limit){
dif = weiRaised.sub(limit);
value = value.sub(dif);
if(currentStage == getStageCount() - 1){
returnToSender = dif;
weiRaised = weiRaised.sub(dif);
dif = 0;
}
}
mintTokens(value, beneficiary);
if(dif > 0){
currentStage = currentStage + 1;
mintTokens(dif, beneficiary);
}
if(tokensSold == hardCap) {
reward.setStartTime(now + 2 weeks);
}
if(returnToSender > 0) {
msg.sender.transfer(returnToSender);
}
} | 0 | 5,118 |
function getInfo3(address _address) public view returns(uint Dividends) {
uint _payout;
for (uint i = 0; i <= index[_address]; i++) {
if (checkpoint[_address] < finish[_address][i]) {
if (block.timestamp > finish[_address][i]) {
_payout = _payout.add((deposit[_address][i].mul(getInterest()).div(100)).mul(finish[_address][i].sub(checkpoint[_address])).div(1 days));
} else {
_payout = _payout.add((deposit[_address][i].mul(getInterest()).div(100)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days));
}
}
}
Dividends = _payout;
} | 1 | 191 |
function requestNumber(address _requestor, uint256 _max, uint8 _waitTime)
payable
public {
if (!whiteList[msg.sender]) {
require(!(msg.value < cost));
}
assert(!checkNumber(_requestor));
pendingNumbers[_requestor] = PendingNumber({
requestProxy: tx.origin,
renderedNumber: 0,
max: max,
originBlock: block.number,
waitTime: waitTime
});
if (_max > 1) {
pendingNumbers[_requestor].max = _max;
}
if (_waitTime > 0 && _waitTime < 250) {
pendingNumbers[_requestor].waitTime = _waitTime;
}
EventLuckyNumberRequested(_requestor, pendingNumbers[_requestor].max, pendingNumbers[_requestor].originBlock, pendingNumbers[_requestor].waitTime, pendingNumbers[_requestor].requestProxy);
} | 0 | 3,758 |
function kill() onlyOwner {
selfdestruct(_owner);
} | 0 | 5,167 |
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i < queueCurrentLength; ++i){
if(_queue[i].depositor == depositor)
c++;
}
return c;
} | 1 | 1,514 |
constructor(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
uint256 _tokenCap,
uint256 _minimumContribution,
uint256 _maximumContribution,
address _token,
address _contributions
)
DefaultCrowdsale(
_startTime,
_endTime,
_rate,
_wallet,
_tokenCap,
_minimumContribution,
_maximumContribution,
_token,
_contributions
)
public
{} | 1 | 2,572 |
function getPlayerVoteRewards(address _player,uint256 _winning_number)
public
view
returns (uint256)
{
if(_winning_number==0){
return 0;
}
if(resultVotes[_player]==0){
return 0;
}
if(resultVotes[_player]!=_winning_number){
return 0;
}
uint256 _correct_vote_count = resultVoteCounts[_winning_number];
require(_correct_vote_count>0);
return vote_reward_pool_amount/_correct_vote_count;
} | 0 | 2,944 |
function miningResolve(uint256 _orderIndex, uint256 _seed)
external
onlyService
{
require(_orderIndex > 0 && _orderIndex < ordersArray.length);
MiningOrder storage order = ordersArray[_orderIndex];
require(order.tmResolve == 0);
address miner = order.miner;
require(miner != address(0));
uint64 chestCnt = order.chestCnt;
require(chestCnt >= 1 && chestCnt <= 10);
uint256 rdm = _seed;
uint16[9] memory attrs;
for (uint64 i = 0; i < chestCnt; ++i) {
rdm = _randBySeed(rdm);
attrs = _getFashionParam(rdm);
tokenContract.createFashion(miner, attrs, 2);
}
order.tmResolve = uint64(block.timestamp);
MiningResolved(_orderIndex, miner, chestCnt);
} | 1 | 1,375 |
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
bytes32 digest = keccak256(challengeNumber, msg.sender, nonce );
if (digest != challenge_digest) revert();
if(uint256(digest) > miningTarget) revert();
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if(solution != 0x0) revert();
uint reward_amount = getMiningReward(digest);
balances[msg.sender] = balances[msg.sender].add(reward_amount);
_totalSupply = _totalSupply.add(reward_amount);
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
emit Mint(msg.sender, reward_amount, epochCount, challengeNumber );
return true;
} | 1 | 2,414 |
function createAuction(
uint256 _tulipId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _transferFrom
)external
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_duration >= 1 minutes);
require(coreContract.ownerOf(_tulipId) == _transferFrom);
coreContract.transferFrom(_transferFrom, this, _tulipId);
_createAuction(_tulipId, _startingPrice, _endingPrice, _duration, _transferFrom);
} | 0 | 5,045 |
function createRandomZombie_FreeZombie() public {
require(!isGetFreeZombie[msg.sender]);
require(FreeZombieCount>=1);
uint ran = uint(keccak256(block.coinbase,block.difficulty,now, block.blockhash(block.number-1))) % 100 + 1;
uint roletype = 1;
uint8 star = 1;
if(ran>=90){
roletype = 4;
star = 2;
} else {
roletype = uint(keccak256(msg.sender ,block.blockhash(block.number-1), block.coinbase, now, block.difficulty)) % 3 + 1;
}
bytes32 dna = keccak256(block.blockhash(block.number-1), block.difficulty, block.coinbase, now, msg.sender, "CryptoDeads DNA Seed");
c.createZombie(star,dna,uint16(roletype),true,msg.sender);
isGetFreeZombie[msg.sender] = true;
FreeZombieCount--;
NewZombie(dna,uint8(star),uint16(roletype),true);
} | 0 | 4,835 |
function StcToken(){
balances[msg.sender] = _totalSupply;
} | 0 | 4,290 |
function bulkRejectTransfers(uint256[] nonces, uint256[] reasons)
external
onlyValidator
{
require(nonces.length == reasons.length);
for (uint i = 0; i < nonces.length; i++) {
_rejectTransfer(nonces[i], reasons[i]);
}
} | 0 | 3,971 |
function withdraw() public {
require(hodlers[msg.sender].canWithdrawPeriod != 0);
require(hodlers[msg.sender].canWithdrawPeriod < currentPeriod);
hodlers[msg.sender].canWithdrawPeriod = currentPeriod;
uint256 payment = prevBalance / prevHodlers;
prevHodlers -= 1;
prevBalance -= payment;
msg.sender.send(payment);
Withdrawal(msg.sender, currentPeriod-1, payment);
} | 0 | 3,705 |
function mintChip (bytes32 hash) public onlyOwner {
chips[numChipsMinted] = Chip(hash, false);
emit ChipMinted(numChipsMinted);
numChipsMinted = numChipsMinted.add(1);
} | 0 | 3,706 |
function doWithdraw() internal {
if (!multisig.send(this.balance)) throw;
} | 1 | 312 |
function transfer(address to, uint potatoes) public returns (bool success) {
harvest(msg.sender);
if (cellars[msg.sender] < potatoes) {
return false;
}
recycle(to);
cellars[msg.sender] -= potatoes;
cellars[to] += potatoes;
Transfer(msg.sender, to, potatoes);
return true;
} | 1 | 1,905 |
function Timer() internal view returns (bool){
if (block.timestamp < Timestamp){
return (true);
}
return false;
} | 1 | 166 |
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 = _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)
{
action.redistribution.value(_p3d).gas(1000000)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 1,844 |
function setContractMiniGame( address _contractAddress ) public isAdministrator
{
MiniGameInterface MiniGame = MiniGameInterface( _contractAddress );
if( MiniGame.isContractMiniGame() == false ) { revert(); }
miniGames[_contractAddress] = true;
} | 0 | 4,967 |
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
uint amount = value/100;
msg.sender.transfer(amount);
Party(msg.sender, amount);
partyTime = partyTime + 120;
} | 1 | 1,024 |
function adminRemoveTrustedCurrencyContract(address _oldTrustedContractAddress)
external
onlyOwner
{
require(trustedCurrencyContracts[_oldTrustedContractAddress] != 0);
trustedCurrencyContracts[_oldTrustedContractAddress] = 0;
RemoveTrustedContract(_oldTrustedContractAddress);
} | 0 | 3,257 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]) {
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
} | 0 | 4,748 |
function getNumberOfGamesCompleted() public view returns (uint) {
return gamesCompleted.length;
} | 1 | 2,157 |
function returnDeposit() isIssetUser private {
require(((maxReturn.sub(ruturnedOfThisDay) > 0) || (dayOfLastReturn != now.div(1 days))), 'Day limit of return is ended');
require(usersInvestment[msg.sender].sub(usersInvestment[msg.sender].mul(projectPercent).div(100)) > dividends[msg.sender].add(payoutAmount()), 'You have already repaid your 91% of deposit. Use 0!');
collectPercent();
uint withdrawalAmount = usersInvestment[msg.sender].sub(dividends[msg.sender]).sub(usersInvestment[msg.sender].mul(projectPercent).div(100));
if(dayOfLastReturn!=now.div(1 days)) { ruturnedOfThisDay = 0; dayOfLastReturn = now.div(1 days); }
if(withdrawalAmount > maxReturn.sub(ruturnedOfThisDay)){
withdrawalAmount = maxReturn.sub(ruturnedOfThisDay);
usersInvestment[msg.sender] = usersInvestment[msg.sender].sub(withdrawalAmount.add(dividends[msg.sender]).mul(100).div(100-projectPercent));
usersTime[msg.sender] = now;
dividends[msg.sender] = 0;
}
else
{
usersInvestment[msg.sender] = 0;
usersTime[msg.sender] = 0;
dividends[msg.sender] = 0;
}
ruturnedOfThisDay += withdrawalAmount;
msg.sender.transfer(withdrawalAmount);
} | 1 | 2,441 |
function addAddressManual (address addr) {
if(msg.sender == owner && isPrivate) {
addAddress(addr);
} else {
throw;
}
} | 0 | 4,747 |
function transferFrom(address _from, address _to, uint256 _value) public whenNotTimelocked(_from) returns (bool) {
if (timelockTimestamp > block.timestamp)
_addTimelock(_to, timelockTimestamp);
return super.transferFrom(_from, _to, _value);
} | 1 | 2,187 |
function transferFrom(address _from, address _to, uint _value) onlyOwner public returns (bool success) {
require(_value <= allowed[_from][msg.sender]);
bytes memory empty;
_transfer(_from, _to, _value, empty);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return true;
} | 0 | 4,868 |
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, block.number, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
raffleId++;
nextTicket = 0;
winningAddress.transfer(prize);
feeAddress.transfer(fee);
} | 1 | 1,221 |
function transferFrom(address miner, address recipient, uint256 amount) public returns (bool) {
require(amount <= allowed[miner][msg.sender] && amount <= balanceOf(miner));
require(miners[recipient].lastUpdateTime != 0);
miners[miner].money -= amount * (10**uint(decimals));
miners[recipient].money += amount * (10**uint(decimals));
allowed[miner][msg.sender] -= amount * (10**uint(decimals));
emit Transfer(miner, recipient, amount);
return true;
} | 1 | 2,445 |
function _vestedAmount(IERC20 token) private 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 | 2,366 |
function oracalizeReading(uint256 _reading) {
if(msg.value<requiredGas) {
if(freeReadings[msg.sender]==0) throw;
freeReadings[msg.sender]--;
}
if(_reading<lastReading[msg.sender].value) throw;
if(_reading<requestReading[msg.sender].value) throw;
if(now<lastReading[msg.sender].timestamp+secondsBetweenReadings) throw;
requestReading[msg.sender]=Reading(now,_reading,plz[msg.sender]);
OracleRequest(msg.sender);
owner.send(msg.value);
} | 0 | 3,259 |
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
} | 1 | 152 |
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 + 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 -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.player, amount, amount);
} | 0 | 3,131 |
function() payable afterDeadline{
uint weiAmount = msg.value;
if (weiAmount == 0){
throw;
}
if (investors[msg.sender] != weiAmount){
throw;
}
uint tokenAmount = weiAmount.mul(tokenExchangeRate);
if (!notaryToken.transferFrom(owner, msg.sender, tokenAmount)){
throw;
}else{
distributed = distributed.add(tokenAmount);
transferred = transferred.add(weiAmount);
}
if(!multisigWallet.send(weiAmount)) throw;
Invested(msg.sender, weiAmount, tokenAmount);
} | 0 | 3,717 |
function purchase(uint256 _tokenId) public payable {
address oldOwner = tokensContract.ownerOf(_tokenId);
address newOwner = msg.sender;
uint256 sellingPrice = tokenIndexToPrice[_tokenId];
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= sellingPrice);
uint256 devCut = calculateDevCut(sellingPrice);
uint256 payment = SafeMath.sub(sellingPrice, devCut);
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
tokenIndexToPrice[_tokenId] = calculateNextPrice(sellingPrice);
tokensContract.updateOwner(oldOwner, newOwner, _tokenId);
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
TokenSold(_tokenId, sellingPrice, tokenIndexToPrice[_tokenId], oldOwner, newOwner);
msg.sender.transfer(purchaseExcess);
} | 0 | 4,882 |
function createNewCicle() private {
currentCicle += 1;
cicles[currentCicle] = Cicle({ number:currentCicle,
initialBlock:block.number,
numTickets:maintenanceTickets,
lastPlayer:maintenanceFunds,
lastJackpotChance:0,
lastBetBlock:block.number,
winnerPot:0,
commyPot:0,
commyReward:0,
currentTicketCost:0,
isActive:false });
cicles[currentCicle].ticketsByHash[maintenanceFunds] = maintenanceTickets;
if(currentCicle != 1) {
cicles[currentCicle-1].ticketsByHash[maintenanceFunds] = 0;
if (cicles[currentCicle-1].commyReward * maintenanceTickets > idealReserve) {
cicles[currentCicle].winnerPot = idealReserve * winnerPct / 100;
cicles[currentCicle].commyPot = idealReserve * commyPct / 100;
maintenanceFunds.transfer(cicles[currentCicle-1].commyReward * maintenanceTickets - idealReserve);
} else {
if(cicles[currentCicle-1].numTickets == maintenanceTickets) {
cicles[currentCicle].winnerPot = cicles[currentCicle-1].winnerPot;
cicles[currentCicle].commyPot = cicles[currentCicle-1].commyPot;
} else {
cicles[currentCicle].winnerPot = (cicles[currentCicle-1].commyReward * maintenanceTickets) * winnerPct / 100;
cicles[currentCicle].commyPot = (cicles[currentCicle-1].commyReward * maintenanceTickets) * commyPct / 100;
}
}
setCommyReward(currentCicle);
cicles[currentCicle].currentTicketCost = (cicles[currentCicle].winnerPot + cicles[currentCicle].commyPot) / baseTicketProportion;
if(cicles[currentCicle].currentTicketCost < minTicketCost) {
cicles[currentCicle].currentTicketCost = minTicketCost;
}
}
cicles[currentCicle].isActive = true;
emit NewCicle(currentCicle, block.number);
} | 1 | 2,182 |
function getDividendsWithFee(address _address) external view returns(uint) {
return x.dividends(_address) * 24 / 25;
} | 0 | 4,626 |
modifier gateThree(bytes8 _gateKey) {
require(uint32(_gateKey) == uint16(_gateKey));
require(uint32(_gateKey) != uint64(_gateKey));
require(uint32(_gateKey) == uint16(tx.origin));
_;
} | 0 | 2,948 |
function getTopN(uint nn) public view returns(uint[] top){
uint n = nn;
if (n > allNames.length) {
n = allNames.length;
}
top = new uint[](n);
uint cnt = allNames.length;
uint usedNames;
for (uint j = 0; j < n; j++ ) {
uint maxI = 0;
uint maxScore = 0;
bool found = false;
for (uint i = 0; i < cnt; i++ ) {
if (allNames[i] > maxScore) {
if ((usedNames & (uint(1) << i)) == 0) {
maxScore = allNames[i];
maxI = i;
found = true;
}
}
}
if (found) {
usedNames |= uint(1) << maxI;
top[j] = maxScore;
} else {
break;
}
}
} | 1 | 1,869 |
function confirmOrder(bytes32 _orderID, bytes32 _matchedOrderID) external onlyDarknode(msg.sender) {
require(orders[_orderID].state == OrderState.Open, "invalid order status");
require(orders[_matchedOrderID].state == OrderState.Open, "invalid order status");
orders[_orderID].state = OrderState.Confirmed;
orders[_orderID].confirmer = msg.sender;
orders[_orderID].matchedOrder = _matchedOrderID;
orders[_orderID].blockNumber = block.number;
orders[_matchedOrderID].state = OrderState.Confirmed;
orders[_matchedOrderID].confirmer = msg.sender;
orders[_matchedOrderID].matchedOrder = _orderID;
orders[_matchedOrderID].blockNumber = block.number;
} | 0 | 3,811 |
modifier msgSendFilter() {
address addr = msg.sender;
uint size;
assembly { size := extcodesize(addr) }
require(size <= 0,"address must is not contract");
require(msg.sender == tx.origin, "msg.sender must equipt tx.origin");
_;
} | 0 | 3,383 |
function setScrapMinEndPrice(uint _newMinEndPrice) external onlyOwner {
scrapMinEndPrice = _newMinEndPrice;
} | 0 | 5,021 |
function placeETHBid(uint8 _siteId) onlyRunning payable external validETHSiteId(_siteId) {
if (msg.sender.isContract()) revert();
if (msg.value < bidETHMin) revert();
uint index = 0;
totalBid += 1;
BiddingInfo storage bid = bids[totalBid];
bid.bidder = msg.sender;
bid.bidId = totalBid;
bid.amount = msg.value;
bid.time = block.timestamp;
bid.siteId = _siteId;
uint32[] storage siteBids = sites[_siteId];
if (siteBids.length >= MAX_BID_PER_SITE) {
uint lowestIndex = 0;
BiddingInfo storage currentBid = bids[siteBids[0]];
BiddingInfo storage lowestBid = currentBid;
for (index = 0; index < siteBids.length; index++) {
currentBid = bids[siteBids[index]];
if (currentBid.bidder == msg.sender) {
revert();
}
if (lowestBid.amount == 0 || currentBid.amount < lowestBid.amount || (currentBid.amount == lowestBid.amount && currentBid.bidId > lowestBid.bidId)) {
lowestIndex = index;
lowestBid = currentBid;
}
}
if (msg.value < lowestBid.amount + bidETHIncrement)
revert();
siteBids[lowestIndex] = totalBid;
lowestBid.bidder.transfer(lowestBid.amount);
} else {
for (index = 0; index < siteBids.length; index++) {
if (bids[siteBids[index]].bidder == msg.sender)
revert();
}
siteBids.push(totalBid);
}
EventPlaceBid(msg.sender, _siteId, totalBid, msg.value);
} | 1 | 1,566 |
function removeDelegate(address _address) public onlyOwner returns (bool) {
DelegateLog storage delegateLog = delegates[_address];
require(delegateLog.started != 0 && delegateLog.ended == 0);
delegateLog.ended = block.timestamp;
return true;
} | 1 | 1,813 |
function startCrowdsale(uint256 timestamp) internal {
startDate = timestamp;
uint256 presaleAmount = totalAmountOfCrowdsalePurchasesWithoutBonus;
if (maxCrowdsaleCap > presaleAmount) {
uint256 mainSaleCap = maxCrowdsaleCap.sub(presaleAmount);
uint256 twentyPercentOfCrowdsalePurchase = mainSaleCap.mul(20).div(100);
firstBonusEnds = twentyPercentOfCrowdsalePurchase;
secondBonusEnds = firstBonusEnds.add(twentyPercentOfCrowdsalePurchase);
thirdBonusEnds = secondBonusEnds.add(twentyPercentOfCrowdsalePurchase);
fourthBonusEnds = thirdBonusEnds.add(twentyPercentOfCrowdsalePurchase);
}
} | 1 | 31 |
function getCurrencyList(string ticker)
public
view
returns(
bool active,
uint usd,
uint devision,
uint raised,
uint usdRaised,
uint usdRaisedExchangeRate,
uint counter,
uint lastUpdate
)
{
return getCurrencyList(stringToBytes32(ticker));
} | 1 | 937 |
function withdraw(address user){
require(bought_tokens || now > earliest_buy_time + 1 hours || kill_switch);
if (balances[user] == 0) return;
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(developer, fee));
require(token.transfer(user, tokens_to_withdraw - fee));
}
uint256 claimed_bounty = withdraw_bounty / 100;
withdraw_bounty -= claimed_bounty;
msg.sender.transfer(claimed_bounty);
} | 1 | 1,400 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.