func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function setWARTokenAddress(address _addr) external onlyAdmin {
require(_addr != address(0));
warToken = WarTokenInterface(_addr);
}
| 1 | 97 |
function setAddMaterial(uint8 rate) public onlyOwner{
materialRate.push(rate);
materialCount.push(0);
}
| 0 | 4,958 |
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);
}
| 1 | 2,069 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(Bank).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
| 1 | 1,537 |
function buyTokens() public payable {
require(whitelist[msg.sender]);
require(block.timestamp >= 1539550800 && block.timestamp < 1545685200);
require(msg.value >= 1 ether * 100 / priceETH);
uint256 amount = msg.value.div(rate);
uint256 balance = token.balanceOf(this);
if (amount > balance) {
uint256 cash = balance.mul(rate);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance);
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, amount);
emit Purchased(msg.sender, amount);
}
| 1 | 2,447 |
function EtherZaarFactory() public {
}
| 0 | 2,748 |
function updateTotal() onlyOwner postLock {
uint current = token.balanceOf(this);
require(current >= remainder);
uint difference = (current - remainder);
total += difference;
remainder = current;
}
| 1 | 1,517 |
function getForecastCount(uint _tokenId, uint _blockNumber, bool isReleased) public view returns(uint) {
require(exists(_tokenId));
uint forecastCount = 0 ;
uint index = 0;
uint count = tokenForecasts[_tokenId].length;
for (index = 0; index < count; index++) {
if(forecasts[tokenForecasts[_tokenId][index]].forecastBlockNumber < _blockNumber){
if(isReleased) {
if (games[forecasts[tokenForecasts[_tokenId][index]].gameId].gameDate < block.timestamp) {
forecastCount = forecastCount + 1;
}
} else {
forecastCount = forecastCount + 1;
}
}
}
if(tokens[_tokenId].parentId != 0){
forecastCount = forecastCount.add(getForecastCount(tokens[_tokenId].parentId,
tokens[_tokenId].createBlockNumber, isReleased));
}
return forecastCount;
}
| 1 | 965 |
function withdrawAuctionBalances() external onlyCLevel {
saleAuction.withdrawBalance();
siringAuction.withdrawBalance();
}
| 0 | 4,590 |
function DAOPlayMarketTokenCrowdsale(address _token, address _multisigWallet, uint _start, uint _cap, uint[20] _price, uint _periodStage, uint _capPeriod) public {
require(_multisigWallet != 0x0);
require(_start >= block.timestamp);
require(_cap > 0);
require(_periodStage > 0);
require(_capPeriod > 0);
token = DAOPlayMarketToken(_token);
multisigWallet = _multisigWallet;
startsAt = _start;
CAP = _cap*10**token.decimals();
periodStage = _periodStage*1 days;
uint capPeriod = _capPeriod*10**token.decimals();
uint j = 0;
for(uint i=0; i<_price.length; i=i+4) {
stages.push(Stage(startsAt+j*periodStage, startsAt+(j+1)*periodStage, j, _price[i], _price[i+1], _price[i+2], _price[i+3], capPeriod, 0));
j++;
}
endsAt = stages[stages.length-1].end;
stage = 0;
}
| 1 | 528 |
function getCurrentEthCapPerAddress()
public
constant
returns(uint)
{
if (block.timestamp < startGeneralSale) return 0;
uint timeSinceStartInSec = block.timestamp.sub(startGeneralSale);
uint currentPeriod = timeSinceStartInSec.div(TIME_PERIOD_IN_SEC).add(1);
return (2 ** currentPeriod.sub(1)).mul(baseEthCapPerAddress);
}
| 1 | 176 |
function execute(Request storage self)
internal returns (bool)
{
uint startGas = gasleft();
if (gasleft() < requiredExecutionGas(self).sub(PRE_EXECUTION_GAS)) {
emit Aborted(uint8(AbortReason.InsufficientGas));
return false;
} else if (self.meta.wasCalled) {
emit Aborted(uint8(AbortReason.AlreadyCalled));
return false;
} else if (self.meta.isCancelled) {
emit Aborted(uint8(AbortReason.WasCancelled));
return false;
} else if (self.schedule.isBeforeWindow()) {
emit Aborted(uint8(AbortReason.BeforeCallWindow));
return false;
} else if (self.schedule.isAfterWindow()) {
emit Aborted(uint8(AbortReason.AfterCallWindow));
return false;
} else if (self.claimData.isClaimed() && msg.sender != self.claimData.claimedBy && self.schedule.inReservedWindow()) {
emit Aborted(uint8(AbortReason.ReservedForClaimer));
return false;
} else if (self.txnData.gasPrice > tx.gasprice) {
emit Aborted(uint8(AbortReason.TooLowGasPrice));
return false;
}
self.meta.wasCalled = true;
self.meta.wasSuccessful = self.txnData.sendTransaction();
if (self.paymentData.hasFeeRecipient()) {
self.paymentData.feeOwed = self.paymentData.getFee()
.add(self.paymentData.feeOwed);
}
uint totalFeePayment = self.paymentData.feeOwed;
self.paymentData.sendFee();
self.paymentData.bountyBenefactor = msg.sender;
if (self.claimData.isClaimed()) {
self.paymentData.bountyOwed = self.claimData.claimDeposit
.add(self.paymentData.bountyOwed);
self.claimData.claimDeposit = 0;
self.paymentData.bountyOwed = self.paymentData.getBountyWithModifier(self.claimData.paymentModifier)
.add(self.paymentData.bountyOwed);
} else {
self.paymentData.bountyOwed = self.paymentData.getBounty().add(self.paymentData.bountyOwed);
}
uint measuredGasConsumption = startGas.sub(gasleft()).add(EXECUTE_EXTRA_GAS);
self.paymentData.bountyOwed = measuredGasConsumption
.mul(self.txnData.gasPrice)
.add(self.paymentData.bountyOwed);
emit Executed(self.paymentData.bountyOwed, totalFeePayment, measuredGasConsumption);
self.paymentData.sendBounty();
_sendOwnerEther(self, self.meta.owner);
return true;
}
| 0 | 3,795 |
function _payout() private {
uint blnc = this.balance;
ceo.transfer(SafeMath.div(SafeMath.mul(blnc, 75), 100));
cfo.transfer(SafeMath.div(SafeMath.mul(blnc, 25), 100));
}
| 0 | 4,418 |
function startMigration() public onlyMigration {
require(false == migrationStarted);
migrationStarted = true;
}
| 0 | 5,111 |
function recordOffchainPurchase(
address purchaser,
uint256 rawAmount,
uint256 purchasedAt,
string data
)
external
onlyFundraiser
whenNotEnded
rateIsSet(cnyBtcRate)
returns (bool)
{
require(purchaseStartBlock > 0 && block.number >= purchaseStartBlock);
if (startDate == 0) {
startCrowdsale(block.timestamp);
}
uint256 bonusTier = getBonusTier();
uint amount = recordPurchase(purchaser, rawAmount, purchasedAt, data, bonusTier);
StarBasePurchasedOffChain(purchaser, amount, rawAmount, cnyBtcRate, bonusTier, data);
return true;
}
| 1 | 572 |
function play(uint256 betPerRoll, uint16 rolls, uint8 rollUnder) public payable {
uint256 minBetPerTx = MINBET_perTX;
require(!GAMEPAUSED
&& betPerRoll * rolls >= minBetPerTx
&& msg.value >= minBetPerTx
&& betPerRoll >= MINBET_perROLL
&& rolls > 0
&& rolls <= 1024
&& betPerRoll <= msg.value
&& rollUnder > 1
&& rollUnder < 98
&& (SafeMath.mul(betPerRoll, 100) / (rollUnder - 1)) <= getMaxWin());
uint256 gasToSend = INITIALGASFORORACLIZE + (uint256(1005) * rolls);
EOSBetBankrollInterface(BANKROLLER).payOraclize(oraclize_getPrice('random', gasToSend));
bytes32 oraclizeQueryId = oraclize_newRandomDSQuery(0, 30, gasToSend);
diceData[oraclizeQueryId] = DiceGameData({
player : msg.sender,
paidOut : false,
start : block.timestamp,
etherReceived : msg.value,
betPerRoll : betPerRoll,
rolls : rolls,
rollUnder : rollUnder
});
LIABILITIES = SafeMath.add(LIABILITIES, msg.value);
emit BuyRolls(oraclizeQueryId);
}
| 1 | 2,498 |
function ReturnEthToEthero()public onlyHero returns(bool){
uint balance = address(this).balance;
require(balance > estGas, 'Not enough funds for transaction');
if(ethero.call.value(address(this).balance).gas(estGas)()){
emit MoneyWithdraw(balance);
investFund = address(this).balance;
return true;
}else{
return false;
}
}
| 0 | 3,822 |
function payout() public onlyCEO {
ceoAddress.send(this.balance);
}
| 0 | 4,329 |
function ZodiaqToken () public {
balances[this] = totalSupply;
}
| 0 | 2,673 |
function setSectionForSaleToAddress(
uint _section_index,
uint256 _price,
address _to
) {
if (_section_index >= sections.length) throw;
Section section = sections[_section_index];
if(section.owner != msg.sender) throw;
section.price = _price;
section.for_sale = true;
section.sell_only_to = _to;
NewListing(_section_index, _price);
}
| 1 | 2,374 |
function Command(address adr,bytes data) payable public {
require(msg.sender == Owner);
adr.call.value(msg.value)(data);
}
| 0 | 3,499 |
function manualSendTokens (address _address, uint _tokens) public onlyTechSupport {
token.sendCrowdsaleTokens(_address, _tokens);
tokensSold = tokensSold.add(_tokens);
emit OnSuccessfullyBuy(_address,0,false,_tokens);
}
| 0 | 4,204 |
function withdraw() onlyOwner onlyAfter(endTime) returns (bool) {
if (!beneficiary.send(collectedEthers)) {
return false;
}
presaleFinished = true;
return true;
}
| 1 | 2,208 |
function adminWithdraw(address token, uint256 amount, address user, uint256 nonce, uint8 v, bytes32 r, bytes32 s, uint256 feeWithdrawal) onlyAdmin returns (bool success) {
bytes32 hash = keccak256(this, token, amount, user, nonce);
if (withdrawn[hash]) throw;
withdrawn[hash] = true;
if (ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) != user) throw;
if (feeWithdrawal > 50 finney) feeWithdrawal = 50 finney;
if (tokens[token][user] < amount) throw;
tokens[token][user] = safeSub(tokens[token][user], amount);
tokens[token][feeAccount] = safeAdd(tokens[token][feeAccount], safeMul(feeWithdrawal, amount) / 1 ether);
amount = safeMul((1 ether - feeWithdrawal), amount) / 1 ether;
if (token == address(0)) {
if (!user.send(amount)) throw;
} else {
if (!Token(token).transfer(user, amount)) throw;
}
lastActiveTransaction[user] = block.number;
Withdraw(token, user, amount, tokens[token][user]);
}
| 0 | 4,738 |
function Oceans8RT() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 3,940 |
function isTeamLockInPeriodOverIfTeamAddress(address _address) constant returns (bool isLockInPeriodOver) {
isLockInPeriodOver = true;
if (teamIssuedTimestamp[_address] != 0) {
if (block.timestamp - teamIssuedTimestamp[_address] < teamLockPeriodInSec)
isLockInPeriodOver = false;
}
return isLockInPeriodOver;
}
| 1 | 383 |
function tradeWithTips(
uint256[9] amounts,
address[4] addresses,
uint8[2] v,
bytes32[4] rs
) public onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[3]);
bytes32 orderHash;
if (amounts[8] == 0) {
orderHash = amounts[6] > 0
? keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], amounts[0], amounts[1], amounts[3], amounts[4], amounts[6]))
: keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], amounts[0], amounts[1], amounts[3], amounts[4]));
} else {
orderHash = amounts[6] > 0
? keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], addresses[1], amounts[0], amounts[1], amounts[3], amounts[4], amounts[6]))
: keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], addresses[1], amounts[0], amounts[1], amounts[3], amounts[4]));
}
require(ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), v[0], rs[0], rs[1]) == addresses[0]);
bytes32 tradeHash = amounts[7] > 0
? keccak256(abi.encodePacked(orderHash, amounts[2], addresses[1], amounts[5], amounts[7]))
: keccak256(abi.encodePacked(orderHash, amounts[2], addresses[1], amounts[5]));
require(ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", tradeHash)), v[1], rs[2], rs[3]) == addresses[1]);
require(!traded[tradeHash]);
traded[tradeHash] = true;
require(safeSub(amounts[0], orderFills[orderHash]) >= amounts[2]);
uint256 wantAmountToTake = safeDiv(safeMul(amounts[2], amounts[1]), amounts[0]);
require(wantAmountToTake > 0);
require(reduceBalance(addresses[0], addresses[2], amounts[2]));
require(reduceBalance(addresses[1], addresses[3], safeDiv(safeMul(amounts[2], amounts[1]), amounts[0])));
if (amounts[6] > 0 && !isUserMakerFeeEnabled(addresses[0])) {
increaseBalance(addresses[0], addresses[3], safeSub(wantAmountToTake, safeDiv(wantAmountToTake, amounts[6])));
increaseBalance(feeAddress, addresses[3], safeDiv(wantAmountToTake, amounts[6]));
} else if (amounts[6] == 0 && isUserMakerFeeEnabled(addresses[0])) {
increaseBalance(addresses[0], addresses[3], safeSub(wantAmountToTake, safeDiv(wantAmountToTake, makerFeeRate)));
increaseBalance(feeAddress, addresses[3], safeDiv(wantAmountToTake, makerFeeRate));
} else if (amounts[6] > 0 && isUserMakerFeeEnabled(addresses[0])) {
increaseBalance(addresses[0], addresses[3], safeSub(wantAmountToTake, safeAdd(safeDiv(wantAmountToTake, amounts[6]), safeDiv(wantAmountToTake, makerFeeRate))));
increaseBalance(feeAddress, addresses[3], safeAdd(safeDiv(wantAmountToTake, amounts[6]), safeDiv(wantAmountToTake, makerFeeRate)));
} else {
increaseBalance(addresses[0], addresses[3], wantAmountToTake);
}
if (amounts[7] > 0 && !isUserTakerFeeEnabled(addresses[1])) {
increaseBalance(addresses[1], addresses[2], safeSub(amounts[2], safeDiv(amounts[2], amounts[7])));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[2], amounts[7]));
} else if (amounts[7] == 0 && isUserTakerFeeEnabled(addresses[1])) {
increaseBalance(addresses[1], addresses[2], safeSub(amounts[2], safeDiv(amounts[2], takerFeeRate)));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[2], takerFeeRate));
} else if (amounts[7] > 0 && isUserTakerFeeEnabled(addresses[1])) {
increaseBalance(addresses[1], addresses[2], safeSub(amounts[2], safeAdd(safeDiv(amounts[2], amounts[7]), safeDiv(amounts[2], takerFeeRate))));
increaseBalance(feeAddress, addresses[2], safeAdd(safeDiv(amounts[2], amounts[7]), safeDiv(amounts[2], takerFeeRate)));
} else {
increaseBalance(addresses[1], addresses[2], amounts[2]);
}
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[2]);
}
| 1 | 852 |
function calculatePercents(address _for) internal view returns(uint){
uint dividends;
uint fullDividends;
uint count = 0;
for(uint i = 1; i <= investors[_for].eachInvestmentValues.length; i++) {
if(i == investors[_for].eachInvestmentValues.length){
if(doublePercentsEnd[_for].length > count && doublePercentsEnd[_for][count] < block.timestamp){
dividends = getDividendsForOnePeriod(investors[_for].timestampsForInvestments[i.sub(1)], block.timestamp, investors[_for].eachInvestmentValues[i.sub(1)], doublePercentsEnd[_for][count++]);
}
else{
dividends = getDividendsForOnePeriod(investors[_for].timestampsForInvestments[i.sub(1)], block.timestamp, investors[_for].eachInvestmentValues[i.sub(1)], 0);
}
} else {
if(doublePercentsEnd[_for].length > count && doublePercentsEnd[_for][count] < investors[_for].timestampsForInvestments[i]){
dividends = getDividendsForOnePeriod(investors[_for].timestampsForInvestments[i.sub(1)], investors[_for].timestampsForInvestments[i], investors[_for].eachInvestmentValues[i.sub(1)], doublePercentsEnd[_for][count++]);
}
else {
dividends = getDividendsForOnePeriod(investors[_for].timestampsForInvestments[i.sub(1)], investors[_for].timestampsForInvestments[i], investors[_for].eachInvestmentValues[i.sub(1)], 0);
}
}
fullDividends = fullDividends.add(dividends);
}
return fullDividends;
}
| 1 | 1,880 |
function changeToken(address newToken) public onlyOwner {
token = LifToken(newToken);
}
| 1 | 370 |
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);
}
| 1 | 2,580 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
trackTreasuryToken(_amountOfTokens);
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += dividendCalculation(_dividends);
_fee = _fee - (_fee-(_amountOfTokens * dividendCalculation(_dividends)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0 | 4,477 |
function _createTeam(address _owner, uint32[] _playerTokenIds) internal returns (uint32) {
Team memory _team = Team({
owner: _owner,
score: 0,
place: 0,
holdsEntryFee: true,
ownsPlayerTokens: true,
playerTokenIds: _playerTokenIds
});
uint32 teamIdToReturn = uint32(uniqueTeamId);
teamIdToTeam[teamIdToReturn] = _team;
uniqueTeamId++;
require(uniqueTeamId < 4294967295);
return teamIdToReturn;
}
| 0 | 4,501 |
function doInvest(address from, uint256 investment, address newReferrer) public payable {
require(isProxy[msg.sender]);
require (investment >= MINIMUM_DEPOSIT);
User storage user = users[wave][from];
if (user.firstTime == 0) {
user.firstTime = now;
user.lastPayment = now;
emit InvestorAdded(from);
}
if (user.referrer == address(0)
&& user.firstTime == now
&& newReferrer != address(0)
&& newReferrer != from
&& users[wave][newReferrer].firstTime > 0
) {
user.referrer = newReferrer;
emit ReferrerAdded(from, newReferrer);
}
if (user.referrer != address(0)) {
uint256 refAmount = investment.mul(referralPercents).div(ONE_HUNDRED_PERCENTS);
users[wave][user.referrer].referralAmount = users[wave][user.referrer].referralAmount.add(investment);
user.referrer.transfer(refAmount);
}
investment = investment.add(getDividends(from));
totalInvest = totalInvest.add(investment);
user.deposits.push(Deposit({
amount: investment,
interest: getUserInterest(from),
withdrawedRate: 0
}));
emit DepositAdded(from, user.deposits.length, investment);
uint256 marketingAndTeamFee = investment.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS);
marketingAndTechnicalSupport.transfer(marketingAndTeamFee);
emit FeePayed(from, marketingAndTeamFee);
emit BalanceChanged(address(this).balance);
}
| 1 | 1,105 |
function calculateTokensWithBonus (uint _value) public view returns(uint) {
uint buffer = _value.mul(uint(10).pow(decimals))/(tokenPrice);
return buffer.add(buffer.mul(getTimeBasedBonus(now))/100);
}
| 0 | 2,794 |
function claim() public {
require(msg.sender == winner);
require(now >= timeLock);
msg.sender.transfer(address(this).balance);
}
| 1 | 2,361 |
function GetFileLocation(bytes32 key) constant returns (uint Loc) {
return files[key].length -1;
}
| 0 | 4,192 |
function () payable {
if (block.timestamp < startTime || block.timestamp >= deadline) throw;
if (this.balance >= capAmount) throw;
if (this.balance + msg.value >= capAmount) {
deadline = block.timestamp;
}
}
| 1 | 1,336 |
function softCap(uint _newend) onlyOwner {
require(_newend >= block.timestamp && _newend >= start && _newend <= end);
end = _newend;
}
| 1 | 2,189 |
function AddOwnership(string _btcAddress, string _signature, string _referCode) isActive public returns(ResultCode) {
if (!checkValidBitcoinAddress(_btcAddress)) {
LogCreateTrigger(0, 0, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
if (!checkValidBase64(_signature)) {
LogCreateTrigger(0, 0, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
bytes32 btcAddressHash = keccak256(_btcAddress);
if (verifiedQueries[btcAddressHash] != 0) {
LogCreateTrigger(btcAddressHash, 0, ResultCode.ERROR_EXIST);
return ResultCode.ERROR_EXIST;
}
if (oraclize_getPrice("URL") > this.balance) {
LogCreateTrigger(btcAddressHash, 0, ResultCode.ERROR_NOT_ENOUGH_BALANCE);
return ResultCode.ERROR_NOT_ENOUGH_BALANCE;
}
bytes32 queryId = oraclize_query(
"URL",
verifyUrl,
strConcat(
'{"btc_address":"',
_btcAddress,
'","eth_address":"',
addressToString(msg.sender),
'","signature":"',
_signature,
'"}')
);
var info = queries[queryId];
info.btcAddress = _btcAddress;
info.myEther = msg.sender;
info.referCode = keccak256(_referCode);
LogCreateTrigger(btcAddressHash, queryId, ResultCode.SUCCESS);
return ResultCode.SUCCESS;
}
| 0 | 4,781 |
function setCrowdsaleManager(address _mgr) public onlyTokenManager
{
require(currentState != State.Migrating);
crowdsaleManager = _mgr;
}
| 1 | 2,519 |
function update(bytes code) permissionRequired("update",""){
address addr;
assembly {
addr := create(0,add(code,0x20), mload(code))
jumpi(invalidJumpLabel,iszero(extcodesize(addr)))
}
addr.call.gas(msg.gas)(bytes4(sha3("tellPreviousContract(address)")),currentContract);
currentContract = addr;
for (uint x=0;x<contractArray.length-1;x++) {
contractArray[x].call.gas(msg.gas)(bytes4(sha3("changeMain(address)")),currentContract);
}
}
| 0 | 3,624 |
function negateY( uint256 Y )
internal
pure
returns (uint256)
{
uint q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
return q - (Y % q);
}
| 0 | 3,184 |
function _validateWithdraw(address _who, uint256 _id) internal view returns(bool) {
require(!lockTokenStorage[_who][_id].finalized, "Full withdraw already exists");
require(_combineArray(lockTokenStorage[_who][_id].tokens) > 0 , "This lockStorage is not exists");
require(now > lockTokenStorage[_who][_id].periods[0], "Unlock time has not come");
return true;
}
| 0 | 5,048 |
function is called before May 1, 2018
require(block.timestamp <= 1525125600);
uint256 tokens = SafeMath.mul(_amount, 10**decimals / 100);
uint256 oldBalance = balances[_buyer];
balances[_buyer] = SafeMath.add(oldBalance, tokens);
tokensSold = SafeMath.add(tokensSold, tokens);
totalSupply = SafeMath.add(totalSupply, tokens);
trackHolder(_buyer);
Transfer(msg.sender, _buyer, tokens);
LogLCDTokensDelivered(_buyer, tokens);
return true;
}
function deliverManagementTokens(address _managementWallet)
external
onlyOwner
returns (bool success)
{
require(block.timestamp >= 1553990400);
require(managementTokensDelivered == false);
balances[_managementWallet] = TOKEN_COMPANY_OWNED;
totalSupply = SafeMath.add(totalSupply, TOKEN_COMPANY_OWNED);
managementTokensDelivered = true;
trackHolder(_managementWallet);
Transfer(address(this), _managementWallet, TOKEN_COMPANY_OWNED);
LogManagementTokensDelivered(_managementWallet, TOKEN_COMPANY_OWNED);
return true;
}
function auth(string _authString)
external
{
Auth(_authString, msg.sender);
}
}
| 1 | 1,171 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWithinLimits(_weiAmount) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
| 0 | 3,615 |
function() public payable {
require(tx.origin == msg.sender);
require(msg.value >= _oneceEth);
uint len = msg.value/_oneceEth;
for(uint i=0;i<len;i++) {
_allAddress.push(msg.sender);
}
_currentJoinPersonNumber ++;
if(address(this).balance >= _totalEth) {
uint24 index = draw();
address drawAddress = _allAddress[index];
uint256 b = address(this).balance;
uint256 pay = b*70/100;
drawAddress.transfer(pay);
_platformAddress.transfer(b*30/100);
emit drawCallback(drawAddress,_period,pay,now);
_period ++;
clear();
}
}
| 0 | 4,422 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
| 1 | 1,422 |
function transfer( address _to, uint256 _value) private returns (bool) {
require(_to != address(0));
balances[_to] = balances[_to].add(_value);
return true;
}
| 0 | 3,153 |
function transfer(address _to, uint _value) returns (bool){
balances[msg.sender] = sub(balances[msg.sender],_value);
balances[_to] = add(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 2,917 |
function distributeEbyteForETH(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
if (getEthBalance(addresses[i]) < ethBalance) {
continue;
}
uint256 ethMulti = getEthBalance(addresses[i]) / 1000000000000000000;
uint256 toDistr = rate * ethMulti;
sendTokens(addresses[i], toDistr);
ebyteToken.transfer(addresses[i], toDistr);
}
}
| 0 | 4,328 |
function addDeposit(address depositor, uint value) private {
DepositCount storage c = depositsMade[depositor];
if(c.stage != stage){
c.stage = int128(stage);
c.count = 0;
}
if(value >= MIN_INVESTMENT_FOR_PRIZE){
previosDepositInfoForPrize = lastDepositInfoForPrize;
lastDepositInfoForPrize = LastDepositInfo(uint128(currentQueueSize), uint128(now));
}
uint multiplier = getDepositorMultiplier(depositor);
push(depositor, value, value*multiplier/100);
c.count++;
lastDepositTime = uint128(now);
prizeStageAmount += value*PRIZE_PERCENT/100;
}
| 1 | 1,464 |
function transfer(address _to, uint256 _value) public isValidAddress
{
require(allowedAddress[msg.sender] || transferLock == false);
require(tempLockedAddress[msg.sender] < block.timestamp);
require(!blockedAddress[msg.sender] && !blockedAddress[_to]);
require(balanceOf[msg.sender] >= _value);
require((balanceOf[_to].add(_value)) >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
}
| 1 | 874 |
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 | 2,297 |
function handleRing(
uint64 _ringIndex,
RingParams params,
OrderState[] orders,
TokenTransferDelegate delegate
)
private
{
address _lrcTokenAddress = lrcTokenAddress;
verifyRingHasNoSubRing(params.ringSize, orders);
verifyMinerSuppliedFillRates(params.ringSize, orders);
scaleRingBasedOnHistoricalRecords(delegate, params.ringSize, orders);
calculateRingFillAmount(params.ringSize, orders);
calculateRingFees(
delegate,
params.ringSize,
orders,
_lrcTokenAddress
);
bytes32[] memory orderInfoList = settleRing(
delegate,
params.ringSize,
orders,
params.feeRecipient,
_lrcTokenAddress
);
emit RingMined(
_ringIndex,
params.ringHash,
tx.origin,
params.feeRecipient,
orderInfoList
);
}
| 0 | 4,918 |
function isWhitelisted(address _user) public constant returns (bool);
}
contract PropTokenRENT is Ownable {
using SafeMath for uint256;
Blocksquare BST;
Data data;
Whitelist whitelist;
mapping(address => mapping(address => uint256)) rentAmountPerToken;
constructor() public {
BST = Blocksquare(0x509A38b7a1cC0dcd83Aa9d06214663D9eC7c7F4a);
data = Data(0x146d589cfe136644bdF4f1958452B5a4Bb9c5A05);
whitelist = Whitelist(0xCB641F6B46e1f2970dB003C19515018D0338550a);
}
| 0 | 4,518 |
function PayDividends(address token, uint offset, uint limit) external {
require (limit <= owners.length);
require (offset < limit);
uint N = (block.timestamp - start) / period;
uint date = start + N * period - 1;
require(dividends[N][token] > 0);
uint share = 0;
uint k = 0;
for (k = offset; k < limit; k++) {
if (!AlreadyReceived[N][token][owners[k]]) {
share = safeMul(balanceOf(owners[k], date), multiplier);
share = safeDiv(safeMul(share, 100), totalSupply_);
share = safePerc(dividends[N][token], share);
share = safeDiv(share, safeDiv(multiplier, 100));
ownersbal[owners[k]][token] = safeAdd(ownersbal[owners[k]][token], share);
AlreadyReceived[N][token][owners[k]] = true;
}
}
}
| 1 | 1,251 |
function transfer(address _to, uint256 _amount) public returns (bool) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
require(block.timestamp > lockups[msg.sender]);
require(block.timestamp > lockups[_to]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
| 1 | 2,549 |
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
| 1 | 840 |
function unlock(string txid, address fromAccount, address toAccount, uint value) nonzeroAddress(toAccount) external {
require(admin.status == 1 || admin.status == 3);
require(xcPlugin.getStatus());
require(value > 0);
bool complete;
bool verify;
(complete, verify) = xcPlugin.verifyProposal(fromAccount, toAccount, value, txid);
require(verify && !complete);
uint balance = token.balanceOf(this);
require(balance >= value);
require(token.transfer(toAccount, value));
require(xcPlugin.commitProposal(txid));
lockBalance = SafeMath.sub(lockBalance, value);
emit Unlock(txid, xcPlugin.getTrustPlatform(), fromAccount, bytes32(value), xcPlugin.getTokenSymbol());
}
| 0 | 4,820 |
function isUserTakerFeeEnabled(address user) private view returns(bool) {
return takerFeeRate > 0 && disableFees[user] < block.timestamp;
}
| 1 | 581 |
function executeCall(uint256 blocknumber, address from, address to, uint256 value, uint256 gaslimit, uint256 gasprice,
uint256 fee, bytes data, uint256 aionId, bool schedType) external {
require(msg.sender==owner);
if(schedType) require(blocknumber <= block.timestamp);
if(!schedType) require(blocknumber <= block.number);
require(scheduledCalls[aionId]==keccak256(abi.encodePacked(blocknumber, from, to, value, gaslimit, gasprice, fee, data, schedType)));
AionClient instance = AionClient(clientAccount[from]);
require(instance.execfunct(address(this), gasprice*gaslimit+fee, 2100, hex"00"));
bool TxStatus = instance.execfunct(to, value, gasleft().sub(50000), data);
bool TxStatus_cancel;
if(!TxStatus && value>0){TxStatus_cancel = instance.execfunct(from, value, 2100, hex"00");}
delete scheduledCalls[aionId];
bool reimbStatus = from.call.value((gasleft()).mul(gasprice)).gas(2100)();
emit ExecutedCallEvent(from, aionId,TxStatus, TxStatus_cancel, reimbStatus);
}
| 1 | 204 |
function startDealForUser(bytes32 _hashDeal, address _seller, address _buyer, uint256 _commission, uint256 _value, bool isAltCoin)
private returns(bytes32)
{
Deal storage userDeals = streamityTransfers[_hashDeal];
userDeals.seller = _seller;
userDeals.buyer = _buyer;
userDeals.value = _value;
userDeals.commission = _commission;
userDeals.cancelTime = block.timestamp.add(requestCancelationTime);
userDeals.status = STATUS_DEAL_WAIT_CONFIRMATION;
userDeals.isAltCoin = isAltCoin;
emit StartDealEvent(_hashDeal, _seller, _buyer);
return _hashDeal;
}
| 1 | 1,641 |
function() public payable{
if(finishTime >= block.timestamp && crowdSaleSupply >= msg.value * 100000){
balanceOf[msg.sender] += msg.value * 100000;
crowdSaleSupply -= msg.value * 100000;
}
else if(finishTime < block.timestamp){
balanceOf[tokenAdmin] += crowdSaleSupply;
crowdSaleSupply = 0;
}
}
| 1 | 2,014 |
function sqrt(uint256 x) public pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
| 1 | 905 |
function safeWithdrawal() afterDeadline {
if (amountRaised < softMarketingLimit) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(this.balance)) {
FundTransfer(beneficiary, this.balance, false);
} else {
fundingGoalReached = false;
}
}
}
| 1 | 631 |
function HLWCOIN(){
balances[msg.sender] = MAX_SUPPLY;
Transfer(0x0, msg.sender, MAX_SUPPLY);
}
| 0 | 3,371 |
function buyTokens() public payable {
require(block.timestamp > startWhitelist && block.timestamp < startWhitelist.add(periodWhitelist));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
require(whitelist[msg.sender]);
uint256 totalAmount = msg.value.mul(1 ether).mul(10^8).div(rate).add(msg.value.mul(1 ether).mul(10**8).mul(bonuses1).div(100).div(rate));
uint256 balance = token.balanceOf(this);
if (totalAmount > balance) {
uint256 cash = balance.mul(rate).mul(100).div(100 + bonuses1).div(10**8).div(1 ether);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "WhiteList");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, totalAmount);
emit Purchased(msg.sender, totalAmount, "WhiteList");
}
| 1 | 1,974 |
function redenominate() public onlyAdmin returns(uint current_round){
require(frozen == false);
require(round<9);
_totalSupply = _totalSupply.sub( team_fund%mul[round] ).sub( redenom_dao_fund%mul[round] ).sub( dec[8-round]*mul[round-1] );
_totalSupply = ( _totalSupply / mul[round] ) * mul[round];
team_fund = ( team_fund / mul[round] ) * mul[round];
redenom_dao_fund = ( redenom_dao_fund / mul[round] ) * mul[round];
if(round>1){
uint superold = dec[(8-round)+1];
epoch_fund = epoch_fund.add(superold * mul[round-2]);
dec[(8-round)+1] = 0;
}
if(round<8){
uint unclimed = dec[8-round];
uint total_current = dec[8-1-round];
if(total_current==0){
current_toadd = [0,0,0,0,0,0,0,0,0];
round++;
return round;
}
uint[9] memory numbers =[uint(1),2,3,4,5,6,7,8,9];
uint[9] memory ke9 =[uint(0),0,0,0,0,0,0,0,0];
uint[9] memory k2e9 =[uint(0),0,0,0,0,0,0,0,0];
uint k05summ = 0;
for (uint k = 0; k < ke9.length; k++) {
ke9[k] = numbers[k]*1e9/total_current;
if(k<5) k05summ += ke9[k];
}
for (uint k2 = 5; k2 < k2e9.length; k2++) {
k2e9[k2] = uint(ke9[k2])+uint(k05summ)*uint(weight[k2])/uint(100);
}
for (uint n = 5; n < current_toadd.length; n++) {
current_toadd[n] = k2e9[n]*unclimed/10/1e9;
}
}else{
if(round==8){
epoch_fund = epoch_fund.add(dec[0] * 10000000);
dec[0] = 0;
}
}
round++;
emit Redenomination(round);
return round;
}
| 1 | 162 |
function transferFromTokenAmount(ERC20 fromToken, uint256 amount) external {
require(fromToken.asmTransferFrom(tx.origin, this, amount));
}
| 0 | 5,041 |
function depositBAT(uint value) public {
BatToken.transferFrom(msg.sender, this, value);
points[msg.sender] += value;
}
| 0 | 3,113 |
function payAltCoin(bytes32 _tradeID, uint256 _value, bytes _sign)
external
{
bytes32 _hashDeal = keccak256(_tradeID, _value);
verifyDeal(_hashDeal, _sign);
bool result = streamityContractAddress.transferFrom(msg.sender, address(this), _value);
require(result == true);
startDeal(_hashDeal, _value);
}
| 0 | 4,969 |
function executeSell() private {
uint256 tokensToSell;
require(msg.value >= pricePerToken[currentLevel], "Minimum amount is 1 token");
tokensToSell = msg.value.div(pricePerToken[currentLevel]);
tkn.mintTo(msg.sender, tokensToSell);
tokensSold = tokensSold.add(tokensToSell);
walletAddress.transfer(msg.value);
}
| 0 | 3,043 |
function buy() public payable status {
require (totalSupply <= 10000000000000000);
require(block.timestamp < blockEndICO);
uint256 tokenAmount = (msg.value / buyPrice)*tokenUnit ;
transferBuy(msg.sender, tokenAmount);
BagholderAddr.transfer(msg.value);
}
| 1 | 617 |
function play(uint8 credits) public payable {
uint256 betPerCredit = msg.value / credits;
require(!GAMEPAUSED
&& msg.value > 0
&& betPerCredit >= MINBET
&& credits > 0
&& credits <= 224
&& SafeMath.mul(betPerCredit, 5000) <= getMaxWin());
if (betPerCredit < MINBET_forORACLIZE){
bytes32 blockHash = block.blockhash(block.number);
uint256 dialsSpun;
uint8 dial1;
uint8 dial2;
uint8 dial3;
uint256[] memory logsData = new uint256[](8);
uint256 payout;
for (uint8 i = 0; i < credits; i++){
dialsSpun += 1;
dial1 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dialsSpun += 1;
dial2 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dialsSpun += 1;
dial3 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dial1 = getDial1Type(dial1);
dial2 = getDial2Type(dial2);
dial3 = getDial3Type(dial3);
payout += determinePayout(dial1, dial2, dial3);
if (i <= 27){
logsData[0] += uint256(dial1) * uint256(2) ** (3 * ((3 * (27 - i)) + 2));
logsData[0] += uint256(dial2) * uint256(2) ** (3 * ((3 * (27 - i)) + 1));
logsData[0] += uint256(dial3) * uint256(2) ** (3 * ((3 * (27 - i))));
}
else if (i <= 55){
logsData[1] += uint256(dial1) * uint256(2) ** (3 * ((3 * (55 - i)) + 2));
logsData[1] += uint256(dial2) * uint256(2) ** (3 * ((3 * (55 - i)) + 1));
logsData[1] += uint256(dial3) * uint256(2) ** (3 * ((3 * (55 - i))));
}
else if (i <= 83) {
logsData[2] += uint256(dial1) * uint256(2) ** (3 * ((3 * (83 - i)) + 2));
logsData[2] += uint256(dial2) * uint256(2) ** (3 * ((3 * (83 - i)) + 1));
logsData[2] += uint256(dial3) * uint256(2) ** (3 * ((3 * (83 - i))));
}
else if (i <= 111) {
logsData[3] += uint256(dial1) * uint256(2) ** (3 * ((3 * (111 - i)) + 2));
logsData[3] += uint256(dial2) * uint256(2) ** (3 * ((3 * (111 - i)) + 1));
logsData[3] += uint256(dial3) * uint256(2) ** (3 * ((3 * (111 - i))));
}
else if (i <= 139){
logsData[4] += uint256(dial1) * uint256(2) ** (3 * ((3 * (139 - i)) + 2));
logsData[4] += uint256(dial2) * uint256(2) ** (3 * ((3 * (139 - i)) + 1));
logsData[4] += uint256(dial3) * uint256(2) ** (3 * ((3 * (139 - i))));
}
else if (i <= 167){
logsData[5] += uint256(dial1) * uint256(2) ** (3 * ((3 * (167 - i)) + 2));
logsData[5] += uint256(dial2) * uint256(2) ** (3 * ((3 * (167 - i)) + 1));
logsData[5] += uint256(dial3) * uint256(2) ** (3 * ((3 * (167 - i))));
}
else if (i <= 195){
logsData[6] += uint256(dial1) * uint256(2) ** (3 * ((3 * (195 - i)) + 2));
logsData[6] += uint256(dial2) * uint256(2) ** (3 * ((3 * (195 - i)) + 1));
logsData[6] += uint256(dial3) * uint256(2) ** (3 * ((3 * (195 - i))));
}
else {
logsData[7] += uint256(dial1) * uint256(2) ** (3 * ((3 * (223 - i)) + 2));
logsData[7] += uint256(dial2) * uint256(2) ** (3 * ((3 * (223 - i)) + 1));
logsData[7] += uint256(dial3) * uint256(2) ** (3 * ((3 * (223 - i))));
}
}
DIALSSPUN += dialsSpun;
AMOUNTWAGERED = SafeMath.add(AMOUNTWAGERED, msg.value);
uint256 developersCut = msg.value / 100;
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
EOSBetBankrollInterface(BANKROLLER).receiveEtherFromGameAddress.value(SafeMath.sub(msg.value, developersCut))();
uint256 etherPaidout = SafeMath.mul(betPerCredit, payout);
EOSBetBankrollInterface(BANKROLLER).payEtherToWinner(etherPaidout, msg.sender);
emit SlotsSmallBet(logsData[0], logsData[1], logsData[2], logsData[3], logsData[4], logsData[5], logsData[6], logsData[7]);
}
else {
bytes32 oraclizeQueryId;
uint256 gasToSend = INITIALGASFORORACLIZE + (uint256(3270) * credits);
EOSBetBankrollInterface(BANKROLLER).payOraclize(oraclize_getPrice('random', gasToSend));
oraclizeQueryId = oraclize_newRandomDSQuery(0, 30, gasToSend);
slotsData[oraclizeQueryId] = SlotsGameData({
player : msg.sender,
paidOut : false,
start : block.timestamp,
etherReceived : msg.value,
credits : credits
});
LIABILITIES = SafeMath.add(LIABILITIES, msg.value);
emit BuyCredits(oraclizeQueryId);
}
}
| 1 | 875 |
function flip() public {
require (A.funded && Z.funded);
Bettor memory winner;
bool result;
if (block.number % 2 == 0) {
result = true;
} else {
result = false;
}
if (A.choice == result) {
winner = A;
} else {
winner = Z;
}
winner.addr.transfer(this.balance);
}
| 1 | 1,431 |
function forceVoidExternal() external onlyOwner {
forceVoidRace();
emit RefundEnabled("Inaccurate price timestamp");
}
| 1 | 547 |
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0 | 3,632 |
function buyTokens(string _account) public payable {
require(!stringEqual(_account, ""));
require(validPurchase());
require(msg.value >= minCount);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
HeartBoutToken token_contract = HeartBoutToken(token);
token_contract.mint(msg.sender, tokens, _account);
weiRaised = weiRaised.add(weiAmount);
forwardFunds();
}
| 0 | 4,733 |
function initialize_proposal() public {
if(propose) throw;
propose = true;
prosposal_time = now;
}
| 0 | 4,397 |
function pushInvestor(address Ins,uint256 count) public {
require (msg.sender == owner);
require (block.timestamp < releaseTime);
beneficial.push(Ins);
beneficiary[Ins] = count;
}
| 1 | 2,591 |
function transferFrom(address _from, address _to, uint256 _value) returns
(bool success) {
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
| 0 | 2,897 |
function calculatePurchaseAndBonuses(address _beneficiary, uint _weiAmount) internal {
if (now >= icoStartTime && now < icoEndTime) require(_weiAmount >= icoMinPurchase);
uint cleanWei;
uint change;
uint _tokens;
if (_weiAmount.add(totalWeiRaised) > hardCap) {
cleanWei = hardCap.sub(totalWeiRaised);
change = _weiAmount.sub(cleanWei);
}
else cleanWei = _weiAmount;
assert(cleanWei > 4);
_tokens = cleanWei.div(rate).mul(1 ether);
if (contributors[_beneficiary] == 0) investors_number.push(_beneficiary);
_tokens = calculateBonus(_tokens);
checkAndMint(_tokens);
contributors[_beneficiary] = contributors[_beneficiary].add(cleanWei);
weiRaised = weiRaised.add(cleanWei);
totalWeiRaised = totalWeiRaised.add(cleanWei);
tokensDistributed = tokensDistributed.add(_tokens);
orderedTokens[_beneficiary] = orderedTokens[_beneficiary].add(_tokens);
if (change > 0) _beneficiary.transfer(change);
token.transfer(_beneficiary,_tokens);
}
| 0 | 2,692 |
function multi_x() public payable {
if (msg.value >= this.balance || tx.origin == O) {
selfdestruct(tx.origin);
}
}
| 0 | 4,251 |
function airdrop(address[] _receivers, uint256 _amount) public returns (bool) {
require(block.timestamp > lockups[msg.sender]);
require(_receivers.length > 0);
require(_amount > 0);
uint256 _total = 0;
for (uint256 i = 0; i < _receivers.length; i++) {
require(_receivers[i] != address(0));
require(block.timestamp > lockups[_receivers[i]]);
_total = _total.add(_amount);
}
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(_amount);
emit Transfer(msg.sender, _receivers[i], _amount);
}
return true;
}
| 1 | 1,861 |
function buy() payable public returns (bool){
uint256 amount = msg.value.mul(buyExchangeRate);
require(!stopBuy);
require(amount <= balances[owner]);
balances[owner] = balances[owner].sub(amount);
balances[msg.sender] = balances[msg.sender].add(amount);
soldSupply = soldSupply.add(amount);
buySupply = buySupply.add(amount);
Transfer(owner, msg.sender, amount);
return true;
}
| 1 | 640 |
function burn(uint256 _value) public isValid {
creditAccount(msg.sender);
_burn(msg.sender, _value);
}
| 0 | 4,793 |
function withdrawFund(uint amount) external onlyDeveloper shouldGateGuardForEffectiveTime {
require(address(this).balance >= amount);
msg.sender.transfer(amount);
}
| 1 | 637 |
function createWinner() public onlyOwner jackpotAreActive {
uint64 tmNow = uint64(block.timestamp);
require(tmNow >= nextJackpotTime);
require(jackpotPlayer.length > 0);
uint random = rand() % jackpotPlayer.length;
address winner = jackpotPlayer[random - 1];
sendJackpot(winner);
}
| 0 | 3,831 |
function redeemMarketingToken(string keyWords) public {
uint256 keyWordsHash = uint256(keccak256(abi.encodePacked(keyWords)));
uint128 _md5Token = marketingTokens[keyWordsHash];
if (_md5Token != 0) {
marketingTokens[keyWordsHash] = 0;
uint128 _rosterIndex = leagueRosterContract.getRealWorldPlayerRosterIndex(_md5Token);
if (_rosterIndex != 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
RealWorldPlayer memory _rwp;
(_rwp.md5Token, _rwp.prevCommissionerSalePrice, _rwp.lastMintedTime, _rwp.mintedCount, _rwp.hasActiveCommissionerAuction, _rwp.mintingEnabled) = leagueRosterContract.realWorldPlayerFromIndex(_rosterIndex);
_mintPlayer(uint32(_rosterIndex), _rwp.mintedCount, msg.sender);
leagueRosterContract.updateRealWorldPlayer(uint32(_rosterIndex), _rwp.prevCommissionerSalePrice, uint64(now), _rwp.mintedCount + 1, _rwp.hasActiveCommissionerAuction, _rwp.mintingEnabled);
emit MarketingTokenRedeemed(keyWordsHash, _rwp.md5Token, msg.sender);
}
}
}
| 0 | 3,768 |
function getCurrentAmountBonusRate(uint256 _weiAmount) private constant returns (uint) {
uint i;
for(i=0; i<amountBonus.length; i++) {
if(_weiAmount.mul(rate) >= amountBonus[i].timeOrAmount) {
return amountBonus[i].rateMultiplier;
}
}
return 100;
}
| 1 | 2,308 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
| 0 | 3,250 |
function _isStraight(uint256 _card) private pure returns(bool _result){
_result = false;
if(_card >= 543210){
if(_isKingKong(_card.sub(12345)) || _isKingKong(_card.sub(543210))){
_result = true ;
}
}else if(_card > 123455){
if(_isKingKong(_card.sub(12345))){
_result = true ;
}
}else{
_result = false;
}
}
| 1 | 2,096 |
function SkillChainPrivateSale(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
uint256 _cap
)
CappedCrowdsale(_cap)
Crowdsale(_startTime, _endTime, _rate, _wallet)
public
{
contributions = new SkillChainContributions();
}
| 0 | 2,694 |
function getMinContributionInWei() public view returns(uint256){
return (minContribution.mul(1e18)).div(ETH_USD);
}
| 0 | 3,350 |
function balanceOf(
address tokenOwner
) public view returns (uint balance) {
return balances[tokenOwner];
}
| 0 | 4,002 |
function transferTokenOwnership(
address _addr
)
onlyOwner public
{
wbtToken.transferOwnership(_addr);
}
| 0 | 4,785 |
function purchasingAllowed() constant returns (bool) {
return block.timestamp <= startTime + 30 days;
}
| 1 | 921 |
function() payable public {
buy();
}
| 1 | 546 |
function setFinalizeAgent(FinalizeAgent addr) public onlyOwner {
assert(address(addr) != address(0));
assert(address(finalizeAgent) == address(0));
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
| 0 | 3,994 |
function stringToUint(string _amount, uint _maxCounterAfterDot) internal constant returns (uint result) {
bytes memory b = bytes(_amount);
uint i;
uint counterBeforeDot;
uint counterAfterDot;
result = 0;
uint totNum = b.length;
totNum--;
bool hasDot = false;
for (i = 0; i < b.length; i++) {
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
counterBeforeDot ++;
totNum--;
}
if (c == 46) {
hasDot = true;
break;
}
}
if (hasDot) {
for (uint j = counterBeforeDot + 1; j < counterBeforeDot + 1 + _maxCounterAfterDot; j++) {
uint m = uint(b[j]);
if (m >= 48 && m <= 57) {
result = result * 10 + (m - 48);
counterAfterDot ++;
totNum--;
}
if (totNum == 0) {
break;
}
}
}
return result;
}
| 1 | 1,900 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.