func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
{
if (playerAddress[myid]==0x0) throw;
var sl_result = result.toSlice();
sl_result.beyond("[".toSlice()).until("]".toSlice());
uint serialNumberOfResult = parseInt(sl_result.split(', '.toSlice()).toString());
playerDieResult[myid] = sl_result.beyond("[".toSlice()).until("]".toSlice()).toString();
var first_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
var second_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
var third_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
playerTempAddress[myid] = playerAddress[myid];
delete playerAddress[myid];
playerTempBetValue[myid] = playerBetValue[myid];
playerBetValue[myid] = 0;
var miltiplier = 0;
totalBets += 1;
totalWeiWagered += playerTempBetValue[myid];
if(parseInt(playerDieResult[myid])==0 || bytes(result).length == 0 || bytes(proof).length == 0){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 3, proof);
if(!playerTempAddress[myid].send(playerTempBetValue[myid])){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 4, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempBetValue[myid]);
}
return;
}
if(first_barrel == 7 && second_barrel == 7 && third_barrel == 7)
{
miltiplier = 20;
}
if(first_barrel == 4 || first_barrel == 11 || first_barrel == 18 || second_barrel == 13 || second_barrel == 19 || third_barrel == 5 || third_barrel == 11 || third_barrel == 18)
{
miltiplier = 2;
}
if((first_barrel == 4 || first_barrel == 11 || first_barrel == 18) && (second_barrel == 13 || second_barrel == 19) && (third_barrel == 5 || third_barrel == 11 || third_barrel == 18))
{
miltiplier = 7;
}
if((first_barrel == 1 || first_barrel == 5 || first_barrel == 12 || first_barrel == 14 || first_barrel == 16 || first_barrel == 20) && (second_barrel == 2 || second_barrel == 5|| second_barrel == 8|| second_barrel == 10 || second_barrel == 16 || second_barrel == 20) && (third_barrel == 2 || third_barrel == 4 || third_barrel == 8 || third_barrel == 13 || third_barrel == 15))
{
miltiplier = 3;
}
if((first_barrel == 2 || first_barrel == 6 || first_barrel == 9 || first_barrel == 13) && (second_barrel == 1 || second_barrel == 3 || second_barrel == 9 || second_barrel == 11 || second_barrel == 17) && (third_barrel == 1 || third_barrel == 3 || third_barrel == 6 || third_barrel == 9 || third_barrel == 12 || third_barrel == 14 || third_barrel == 20))
{
miltiplier = 5;
}
if((first_barrel == 2 || first_barrel == 9) && (second_barrel == 3 || second_barrel == 17) && (third_barrel == 3 || third_barrel == 12 || third_barrel == 14))
{
miltiplier = 10;
}
if((first_barrel == 6) && (second_barrel == 1 || second_barrel == 11) && (third_barrel == 6 || third_barrel == 9))
{
miltiplier = 12;
}
if((first_barrel == 13) && (second_barrel == 9) && (third_barrel == 1 || third_barrel == 20))
{
miltiplier = 15;
}
if(miltiplier > 0){
playerTempReward[myid] = playerTempBetValue[myid] * miltiplier;
totalWeiWon = safeAdd(totalWeiWon, playerTempReward[myid]);
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempReward[myid], miltiplier, 1, proof);
if(!playerTempAddress[myid].send(playerTempReward[myid])){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempReward[myid], miltiplier, 2, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempReward[myid]);
}
return;
}
if(miltiplier == 0){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 0, proof);
if(!playerTempAddress[myid].send(1)){
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], 1);
}
return;
}
}
| 1
| 6,223
|
function migrateMntp(string _gmAddress) public {
require((state==State.MigrationStarted) || (state==State.MigrationFinished));
uint myBalance = mntpToken.balanceOf(msg.sender);
require(0!=myBalance);
uint myRewardMax = calculateMyRewardMax(msg.sender);
uint myReward = calculateMyReward(myRewardMax);
goldToken.transferRewardWithoutFee(msg.sender, myReward);
mntpToken.burnTokens(msg.sender,myBalance);
Migration memory mig;
mig.ethAddress = msg.sender;
mig.gmAddress = _gmAddress;
mig.tokensCount = myBalance;
mig.migrated = false;
mig.date = uint64(now);
mig.comment = '';
mntpMigrations[mntpMigrationsCount + 1] = mig;
mntpMigrationIndexes[msg.sender] = mntpMigrationsCount + 1;
mntpMigrationsCount++;
MntpMigrateWanted(msg.sender, _gmAddress, myBalance);
}
| 1
| 6,385
|
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
| 0
| 14,985
|
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);
}
}
| 0
| 18,033
|
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner_, newOwner);
owner_ = newOwner;
}
| 0
| 15,395
|
function getPendingReward(ERC20 _token, address _holder) public constant returns(uint) {
uint acc =0;
for (uint i=nextDepositToPayout[msg.sender]; i<deposits.length; i++) {
Deposit storage d = deposits[i];
if ((d.token == _token)&&(!d.canceled) && (!isDepositSkiped(_holder, i))) {
acc += d.amount *
rewardToken.balanceOfAt(_holder, d.block) /
rewardToken.totalSupplyAt(d.block);
}
}
return acc;
}
| 0
| 17,697
|
function can be called only when _mode==2");
require(_distDay != 0,"you haven't distributed");
require(_fFinish == false, "not finish");
require(_fCancelDist == false, "must not cancel dist");
uint256 daysAfterDist;
uint256 expectAmount;
uint256 tday = today();
uint256 expectReleaseTimesNoLimit = 0;
for(uint256 i=0;i<_details.length;i++){
if (_details[i].isFinish == true) {
continue;
}
require(tday!=_details[i].lastTransferDay,"you have applied for todays token");
daysAfterDist = sub(tday,_distDay);
if(daysAfterDist >= _details[i].lockDay){
expectReleaseTimesNoLimit = add(sub(daysAfterDist,_details[i].lockDay),1);
expectAmount = min(add(mul(expectReleaseTimesNoLimit,_details[i].oneDayTransferAmount),_details[i].initAmount),_details[i].distAmount);
_erc20token.transfer(
_details[i].founder,
sub(expectAmount, _details[i].transferedAmount)
);
_details[i].transferedAmount = expectAmount;
_details[i].lastTransferDay = tday;
}
}
| 1
| 6,357
|
function buyTokens(address _investor) public payable {
require(msg.value >= 1e16);
uint256 exchangeRate = rate;
uint256 bonus = 0;
uint256 investment = msg.value;
uint256 remainder = 0;
if(investment >= 1e18 && investment < 2e18) {
bonus = 30;
} else if(investment >= 2e18 && investment < 3e18) {
bonus = 35;
} else if(investment >= 3e18 && investment < 4e18) {
bonus = 40;
} else if(investment >= 4e18 && investment < 5e18) {
bonus = 45;
} else if(investment >= 5e18) {
bonus = 50;
}
exchangeRate = rate.mul(bonus).div(100).add(rate);
uint256 toTransfer = 0;
if(investment > 10e18) {
uint256 bonusCap = 10e18;
toTransfer = bonusCap.mul(exchangeRate);
remainder = investment.sub(bonusCap);
toTransfer = toTransfer.add(remainder.mul(rate));
} else {
toTransfer = investment.mul(exchangeRate);
}
PROV.transfer(_investor, toTransfer);
TokenPurchase(_investor, toTransfer);
tokensSold = tokensSold.add(toTransfer);
fundsWallet.transfer(investment);
}
| 1
| 750
|
function emitTransfer(address _from, address _to, uint256 _value) public onlyLogic {
emit Transfer(_from, _to, _value);
}
| 0
| 12,430
|
function doTakerPayment() internal {
require ((tokenContract.controller() != 0) && (msg.value != 0) );
tokenContract.pledgeFees(msg.value);
require (vaultAddress.send(msg.value));
LogContributions (msg.sender, msg.value, false);
return;
}
| 1
| 742
|
function changeExchange(uint256 _ETHUSD) public {
require(wallets[uint8(Roles.manager)] == msg.sender || wallets[uint8(Roles.observer)] == msg.sender);
require(_ETHUSD >= 1 ether);
softCap=softCap.mul(exchange).div(_ETHUSD);
hardCap=hardCap.mul(exchange).div(_ETHUSD);
minPay=minPay.mul(exchange).div(_ETHUSD);
rate=rate.mul(_ETHUSD).div(exchange);
for (uint16 i = 0; i < bonuses.length; i++) {
bonuses[i].value=bonuses[i].value.mul(exchange).div(_ETHUSD);
}
financialStrategy.setup(wallets[uint8(Roles.beneficiary)], exchange, _ETHUSD, 5);
exchange=_ETHUSD;
}
| 1
| 176
|
function burn(uint256 _value) returns (bool success) {
if (balanceOf[msg.sender] < _value) throw;
if (_value <= 0) throw;
balanceOf[msg.sender] = SafeMath.safeSubtract(balanceOf[msg.sender], _value);
totalSupply = SafeMath.safeSubtract(totalSupply,_value);
Burn(msg.sender, _value);
return true;
}
| 0
| 10,585
|
function order(address _buyTokenAddress, uint256 _buyAmount, address _sellTokenAddress, uint256 _sellAmount, address _takeAddress, address _baseTokenAddress, uint256 _expireBlock, uint256 _nonce) public hasPayloadSize(8 * 32) {
require (_checkTrade(_buyTokenAddress, _buyAmount, _sellTokenAddress, _sellAmount, _baseTokenAddress));
bytes32 hash = _buildHash(_buyTokenAddress, _buyAmount, _sellTokenAddress, _sellAmount, _takeAddress, _baseTokenAddress, _expireBlock, _nonce);
require (!orders[msg.sender][hash]);
orders[msg.sender][hash] = true;
emit Order(_buyTokenAddress, _buyAmount, _sellTokenAddress, _sellAmount, _takeAddress, _baseTokenAddress, _expireBlock, _nonce, msg.sender);
}
| 0
| 18,872
|
constructor(address _multisig, address _restricted) public {
multisig = _multisig;
restricted = _restricted;
restrictedPercent = 10;
hardcap = 900 * 1 ether;
softcap = 30 * 1 ether;
rate = 112600 * token.decimalMultiply();
currentRound = 1;
firstBonusPercent = 50;
secondBonusPercent = 25;
thirdBonusPercent = 10;
}
| 1
| 8,753
|
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;
}
| 0
| 15,043
|
function () public payable {
require(now >= startDate && now <= endDate);
uint tokens;
if (now <= bonusEnds) {
tokens = msg.value * 60000;
} else {
tokens = msg.value * 50000;
}
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
}
| 0
| 12,483
|
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
SPCdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
buyCore(_pID, _affCode, 2, _eventData_);
}
| 1
| 5,863
|
function createTokens() whenNotPaused isUnderHardCap saleIsOn payable {
require(msg.value > 100000000000000000);
uint milestoneIndex = currentMilestone();
Milestone storage milestone = milestones[milestoneIndex];
if(!isSoftcapOn) {
multisigWallet.transfer(msg.value);
}
invested = invested.add(msg.value);
uint tokens = msg.value.mul(1 ether).div(price);
uint bonusTokens = tokens.mul(milestone.bonus).div(percentRate);
uint tokensWithBonus = tokens.add(bonusTokens);
token.mint(this, tokensWithBonus);
token.transfer(msg.sender, tokensWithBonus);
balances[msg.sender] = balances[msg.sender].add(msg.value);
}
| 1
| 5,000
|
function setOracleCallbackGasLimit(uint _newLimit) external onlyOwner {
oracleCallbackGasLimit = _newLimit;
}
| 1
| 8,310
|
function payoutSize(address _to) view public returns(uint) {
uint max = investors[_to].invested.mul(MULTIPLICATION);
if(investors[_to].invested == 0 || investors[_to].payouts >= max) return 0;
uint payout = investors[_to].invested.mul(bonusSize()).div(100).mul(block.timestamp.sub(investors[_to].last_payout)).div(1 days);
return investors[_to].payouts.add(payout) > max ? max.sub(investors[_to].payouts) : payout;
}
| 0
| 13,542
|
function setSiringAuctionAddress(address _address) external onlyCEO {
SiringClockAuction candidateContract = SiringClockAuction(_address);
require(candidateContract.isSiringClockAuction());
siringAuction = candidateContract;
}
| 1
| 381
|
function increaseLotteryBalance(uint value) internal {
lotteryBalance = lotteryBalance.add(value);
}
| 0
| 13,940
|
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
| 1
| 6,535
|
function getNumEthTweets() external constant returns(uint256) {
return ethTweets.length;
}
| 0
| 12,577
|
constructor(
uint256 _rate,
JavvyMultiSig _wallet,
JavvyToken _token,
uint256 _cap,
uint256 _goal,
address _bonusAddress,
address[] _blacklistAddresses,
uint256 _USDETHRate
)
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_cap)
TimedCrowdsale(getStartPreIco(), getEndIco())
RefundableCrowdsale(_goal)
public {
require(getStartIco() > block.timestamp, "ICO has to begin in the future");
require(getEndIco() > block.timestamp, "ICO has to end in the future");
require(_goal <= _cap, "Soft cap should be equal or smaller than hard cap");
icoStartTime = getStartIco();
bonusAddress = _bonusAddress;
token = _token;
for (uint256 i = 0; i < _blacklistAddresses.length; i++) {
blacklisted[_blacklistAddresses[i]] = true;
}
setUSDETHRate(_USDETHRate);
}
| 0
| 9,786
|
function ContractPlay() {
owner = msg.sender;
}
| 0
| 10,413
|
function moveToRST() validAddress(rst) {
sendToRstForAddress( msg.sender );
}
| 0
| 17,206
|
function withdrawCoindropsToken() public {
require(coindropsLockEndingAt <= getBlockTime());
require(coindropsStatus == false);
bytes memory empty;
token.transfer(coindropsWallet, coindropsTokens, empty);
coindropsStatus = true;
}
| 1
| 5,970
|
function grantAppeal(address listingAddress, string data) external onlyAppellate {
Listing storage listing = listings[listingAddress];
Appeal storage appeal = appeals[listing.challengeID];
require(appeal.appealPhaseExpiry > now, "Judge Appeal phase not active");
require(!appeal.appealGranted, "Appeal has already been granted");
appeal.appealGranted = true;
appeal.appealOpenToChallengeExpiry = now.add(parameterizer.get("challengeAppealLen"));
emit _AppealGranted(listingAddress, listing.challengeID, data);
}
| 1
| 9,102
|
function cancelBetByB(uint betid)
private
{
bets[betid].playerAddressB = address(0x0);
bets[betid].betState = BET_STATE_WAITPAIR;
uint betpriceid = getBetPriceID(bets[betid].betPrice);
waitPairBetIDs[betpriceid] = betid;
sendCancelValue(bets[betid].playerAddressB ,betid,false);
}
| 0
| 14,575
|
function receiveETH(address beneficiary) internal stopInEmergency respectTimeFrame {
if (msg.value < minInvestETH) throw;
uint rlcToSend = bonus(safeMul(msg.value,RLCPerETH)/(1 ether));
if (safeAdd(rlcToSend, safeAdd(RLCSentToETH, RLCSentToBTC)) > maxCap) throw;
Backer backer = backers[beneficiary];
if (!rlc.transfer(beneficiary, rlcToSend)) throw;
backer.rlcSent = safeAdd(backer.rlcSent, rlcToSend);
backer.weiReceived = safeAdd(backer.weiReceived, msg.value);
ETHReceived = safeAdd(ETHReceived, msg.value);
RLCSentToETH = safeAdd(RLCSentToETH, rlcToSend);
emitRLC(rlcToSend);
ReceivedETH(beneficiary,ETHReceived);
}
| 1
| 4,610
|
constructor(
address coordinator,
address factory,
uint256 providerPubKey,
bytes32 providerTitle
){
coord = ZapCoordinatorInterface(coordinator);
reserveToken = FactoryTokenInterface(coord.getContract("ZAP_TOKEN"));
reserveToken.approve(coord.getContract("BONDAGE"), ~uint256(0));
tokenFactory = TokenFactoryInterface(factory);
RegistryInterface registry = RegistryInterface(coord.getContract("REGISTRY"));
registry.initiateProvider(providerPubKey, providerTitle);
status = ContestStatus.Uninitialized;
}
| 1
| 9,234
|
function admin() public view returns(address) {
return _admin;
}
| 0
| 13,385
|
function buyPerUnit(address _asset, uint256 _amount) external payable {
require(blacklist[msg.sender] == false);
ListAsset storage listing = listOfAssets[_asset];
require(_amount <= listing.amount);
uint totalPrice = _amount.mul(listing.price);
require(msg.value == totalPrice);
ERC20_Interface token = ERC20_Interface(_asset);
if(token.allowance(owner,address(this)) >= _amount){
assert(token.transferFrom(owner,msg.sender, _amount));
owner.transfer(totalPrice);
listing.amount= listing.amount.sub(_amount);
}
emit BuyDDA(_asset,msg.sender,_amount,totalPrice);
}
| 1
| 984
|
function reward(uint256 _competitionId, uint256 _teamIdx) external whenNotPaused {
require(_teamIdx < 32);
SponsorsInfo storage si = sponsorInfos[_competitionId][_teamIdx];
uint256 baseValue = si.sponsors[msg.sender];
require(baseValue > 0);
CompetitionInfo storage ci = competitionInfos[_competitionId];
if (ci.status == CompetitionStatus.Cancel) {
delete si.sponsors[msg.sender];
require(joyTokenContract.transfer(msg.sender, baseValue));
} else if (ci.status == CompetitionStatus.End) {
require(ci.teamWinCounts[_teamIdx] > 0);
uint256 rewardValue = baseValue.mul(_getWinCountWeight(ci.teamWinCounts[_teamIdx]));
rewardValue = ci.totalReward.mul(rewardValue) / ci.totalWeight;
rewardValue = rewardValue.add(baseValue);
Reward(_competitionId, ci.users[_teamIdx], ci.teamWinCounts[_teamIdx], msg.sender, baseValue, rewardValue);
delete si.sponsors[msg.sender];
require(joyTokenContract.transfer(msg.sender, rewardValue));
}
}
| 1
| 439
|
function SellableToken(
address _multivestAddress,
address _developeo,
address _etherHolder,
uint256 _startTime,
uint256 _endTime,
uint256 _etherPriceInUSD,
uint256 _maxTokenSupply
) public Multivest(_multivestAddress)
{
require(_developeo != address(0));
developeo = Developeo(_developeo);
require((_startTime < _endTime));
etherHolder = _etherHolder;
require((_maxTokenSupply == uint256(0)) || (_maxTokenSupply <= developeo.maxSupply()));
startTime = _startTime;
endTime = _endTime;
etherPriceInUSD = _etherPriceInUSD;
maxTokenSupply = _maxTokenSupply;
priceUpdateAt = block.timestamp;
oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
}
| 1
| 7,685
|
function acceptContribution() public payable {
require(tokenContract.balanceOf(this) >= tokensPerContributor);
require(msg.value == acceptableEthAmountInWei);
tokensDistributed += tokensPerContributor;
contributionsMade += 1;
require(tokenContract.transfer(msg.sender, tokensPerContributor));
}
| 1
| 3,781
|
function withdrawBalance() external onlyOwner {
uint256 totalBalance = address(this).balance;
require(totalBalance > totalCommissionOwed, "There is no ETH for the owner to claim.");
owner.transfer(totalBalance - totalCommissionOwed);
}
| 1
| 5,385
|
function totalSupply() public constant returns (uint){
return _totalSupply* 10**uint(decimals);
}
| 0
| 15,146
|
constructor(uint256 closingTime) public TimedCrowdsale(block.timestamp, closingTime) { }
| 0
| 17,848
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
_postTransferHook(_from, _to, _value);
return true;
}
| 0
| 10,144
|
function finalize()
public
{
require(finalizeable(), "Not ready to draw results");
uint256 _pRoundTicketSum = round[curRoundId].pBoughtTicketSum[msg.sender];
uint256 _bountyTicketSum = _pRoundTicketSum * bountyPercent / 100;
endRound(msg.sender, _bountyTicketSum);
initRound();
mintSlot(msg.sender, _bountyTicketSum, 0, 0);
}
| 1
| 9,124
|
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = GoalbonanzaBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
| 0
| 9,995
|
function TRLCoinSale(address walletAddress) public {
owner = msg.sender;
tokenWallet = ERC20Interface(walletAddress);
require(tokenWallet.totalSupply() == TOTAL_TOKENS_AVAILABLE);
require(tokenWallet.balanceOf(owner) >= TOTAL_TOKENS_TO_DISTRIBUTE);
uint coinToTokenFactor = 10 ** TRLCOIN_DECIMALS;
preSale.start = 1520812800;
preSale.end = 1523491199;
preSale.priceInWei = (1 ether) / (20000 * coinToTokenFactor);
preSale.tokens = TOTAL_TOKENS_TO_DISTRIBUTE / 2;
smallBonus = 10;
largeBonus = 20;
largeBonusStopTime = 1521504000;
sale.start = 1523491200;
sale.end = 1531378799;
sale.priceInWei = (1 ether) / (10000 * coinToTokenFactor);
sale.tokens = TOTAL_TOKENS_TO_DISTRIBUTE / 2;
distributionTime = 1531378800;
tokensRemainingForSale = 0;
tokensAwardedForSale = 0;
}
| 1
| 1,226
|
function finish(string _name) deedValid(_name) ifNotPaused public {
Sale storage s = sales[_name];
require(now > s.auctionEnds);
Deed deed;
(,deed,,,) = registrar.entries(keccak256(_name));
address previousOwner = deed.previousOwner();
registrar.transfer(keccak256(_name), s.lastBidder);
Transfer(previousOwner, s.lastBidder, _name, s.lastBid);
distributeFunds(s.lastBid, previousOwner, s.startReferrer, s.bidReferrer);
delete sales[_name];
withdraw();
}
| 1
| 7,809
|
function setWithdrawal(address drawer, uint256 weiAmount) internal returns (bool success) {
if ((drawer != address(0)) && (weiAmount > 0)) {
uint256 oldBalance = pendingWithdrawals[drawer];
uint256 newBalance = oldBalance + weiAmount;
if (newBalance > oldBalance) {
pendingWithdrawals[drawer] = newBalance;
Withdrawal(drawer, weiAmount);
return true;
}
}
return false;
}
| 0
| 14,704
|
function UNITPaymentGatewayList()
public
{
setAdministrator(tx.origin);
}
| 0
| 12,614
|
function () payable public {
require(msg.value > 1 ether);
require(now > startDate);
require(now < endDate);
uint amount = msg.value * price;
uint _amount = amount / 4;
amount += _amount;
tokenReward.transferFrom(owner, msg.sender, amount);
emit FundTransfer(msg.sender, amount, true);
owner.transfer(msg.value);
}
| 0
| 17,471
|
function finishICO() public onlyInState(State.ICORunning) {
require(msg.sender == creator || isIcoFinished());
setState(State.ICOFinished);
mntToken.lockTransfer(false);
icoTokensUnsold = safeSub(ICO_TOKEN_SUPPLY_LIMIT,icoTokensSold);
if(icoTokensUnsold>0){
mntToken.issueTokens(unsoldContract,icoTokensUnsold);
unsoldContract.finishIco();
}
uint sendThisAmount = (this.balance / 10);
for(uint i=0; i<9; ++i){
address ms = multisigs[i];
if(this.balance>=sendThisAmount){
ms.transfer(sendThisAmount);
}
}
if(0!=this.balance){
address lastMs = multisigs[9];
lastMs.transfer(this.balance);
}
}
| 1
| 903
|
function buyCreditsAndSpendAndRecover(string _id, uint256 _value, uint8 _reason, address _register, uint256 _spend, address _recover ) public onlyOwnerOrOverride returns(uint256) {
buyCreditsAndSpend(_id, _value, _reason, _register, _spend);
return reduceCredits(_id, getCreditsFor(_id), _reason, _recover);
}
| 1
| 6,434
|
function changeOwnerAddress(address newOwner)
onlyOwner {
if (newOwner == address(0x0)) throw;
owner = newOwner;
LOG_OwnerAddressChanged(owner, newOwner);
}
| 1
| 4,518
|
function totalSupply() public constant returns (uint) {
return totalSupply - balanceOf[address(0)];
}
| 0
| 10,569
|
function closeAirdrop() private {
address _owner = ctu_owner;
address _spender = address(this);
uint256 _remain = ctuContract.allowance(_owner, _spender);
if (_remain < reward) {
reward = 0;
remainAirdrop = 0;
}
}
| 1
| 9,386
|
function () external payable {
uint256 tokensThatWillBeMintedAfterPurchase = msg.value.mul(rate);
if ((stage == CrowdsaleStage.PreICOFirst) && (token.totalSupply() + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringPreICO)) {
msg.sender.transfer(msg.value);
EthRefunded("PreICOFirst Limit Hit");
return;
}
if ((stage == CrowdsaleStage.PreICOSecond) && (token.totalSupply() + tokensThatWillBeMintedAfterPurchase > totalTokensForSaleDuringPreICO)) {
msg.sender.transfer(msg.value);
EthRefunded("PreICOSecond Limit Hit");
return;
}
buyTokens(msg.sender);
if (stage == CrowdsaleStage.PreICOFirst) {
totalWeiRaisedDuringPreICO = totalWeiRaisedDuringPreICO.add(msg.value);
}
if (stage == CrowdsaleStage.PreICOSecond) {
totalWeiRaisedDuringPreICO = totalWeiRaisedDuringPreICO.add(msg.value);
}
}
| 1
| 6,315
|
function transferFrom(
address src, address dst, uint wad
) stoppable note returns (bool) {
require(wlcontract.whiteList(src));
require(wlcontract.whiteList(dst));
return super.transferFrom(src, dst, wad);
}
| 1
| 366
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(msg.value != 0);
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(beneficiary, weiAmount);
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary, tokens);
TokenPurchase(
msg.sender,
beneficiary,
weiAmount,
tokens
);
participated[beneficiary] = true;
forwardFunds();
}
| 1
| 9,568
|
function _restart() private {
require(swapOpen);
require(swapLimit == 0);
cycleMintSupply = 0;
swapOpen = false;
isMiningOpen = true;
cycleEndTime = now + 100 days;
emit MiningRestart(cycleEndTime);
}
| 1
| 3,079
|
function addToPrivateSaleWhitelist(address[] _bidder_addresses) public isOwner {
for (uint32 i = 0; i < _bidder_addresses.length; i++) {
privatesalewhitelist[_bidder_addresses[i]] = true;
PrivateSaleWhitelisted(_bidder_addresses[i]);
}
}
| 0
| 12,049
|
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;
}
| 1
| 3,016
|
function resetMaxOutInWeek(uint256 from, uint256 to) public mustBeAdmin {
require(from >= 0 && to < investorAddresses.length);
for (uint256 i = from; i < to; i++) {
address investorAddress = investorAddresses[i];
if (investors[investorAddress].maxOutTimesInWeek == 0) continue;
investors[investorAddress].maxOutTimesInWeek = 0;
}
}
| 0
| 14,728
|
function random(uint lessThan) internal returns (uint) {
seed += block.timestamp + uint(msg.sender);
return uint(sha256(toBytes(uint(blockhash(block.number - 1)) + seed))) % lessThan;
}
| 0
| 11,109
|
function setOwner(address owner_0xB860c949A5fbE39731893bbfE86D6Df57C2851c7)
public
auth
{
owner = owner_0xB860c949A5fbE39731893bbfE86D6Df57C2851c7;
emit LogSetOwner(owner);
}
| 0
| 14,307
|
function setupRace(uint delay, uint locking_duration) onlyOwner beforeBetting public payable returns(bool) {
if (oraclize_getPrice("URL")*3 + oraclize_getPrice("URL", horses.customGasLimit)*3 > address(this).balance) {
emit newOraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee");
return false;
} else {
chronus.starting_time = uint32(block.timestamp);
chronus.betting_open = true;
bytes32 temp_ID;
emit newOraclizeQuery("Oraclize query was sent, standing by for the answer..");
delay = delay.add(60);
chronus.betting_duration = uint32(delay);
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.ETH;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.LTC;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.BTC;
delay = delay.add(locking_duration);
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.ETH;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.LTC;
temp_ID = oraclize_query(delay, "URL", "json(https:
oraclizeIndex[temp_ID] = horses.BTC;
chronus.race_duration = uint32(delay);
return true;
}
}
function reward() internal {
horses.BTC_delta = int32(coinIndex[horses.BTC].post - coinIndex[horses.BTC].pre)*100000/int32(coinIndex[horses.BTC].pre);
horses.ETH_delta = int32(coinIndex[horses.ETH].post - coinIndex[horses.ETH].pre)*100000/int32(coinIndex[horses.ETH].pre);
horses.LTC_delta = int32(coinIndex[horses.LTC].post - coinIndex[horses.LTC].pre)*100000/int32(coinIndex[horses.LTC].pre);
total_reward = (coinIndex[horses.BTC].total) + (coinIndex[horses.ETH].total) + (coinIndex[horses.LTC].total);
if (total_bettors <= 1) {
chronus.voided_bet=true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
} else {
uint house_fee = total_reward.mul(5).div(100);
require(house_fee < address(this).balance);
total_reward = total_reward.sub(house_fee);
bettingControllerInstance.depositHouseTakeout.value(house_fee)();
}
if (horses.BTC_delta > horses.ETH_delta) {
if (horses.BTC_delta > horses.LTC_delta) {
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.BTC].total;
}
else if(horses.LTC_delta > horses.BTC_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else {
winner_horse[horses.BTC] = true;
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.BTC].total + (coinIndex[horses.LTC].total);
}
} else if(horses.ETH_delta > horses.BTC_delta) {
if (horses.ETH_delta > horses.LTC_delta) {
winner_horse[horses.ETH] = true;
winnerPoolTotal = coinIndex[horses.ETH].total;
}
else if (horses.LTC_delta > horses.ETH_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else {
winner_horse[horses.ETH] = true;
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.LTC].total);
}
} else {
if (horses.LTC_delta > horses.ETH_delta) {
winner_horse[horses.LTC] = true;
winnerPoolTotal = coinIndex[horses.LTC].total;
} else if(horses.LTC_delta < horses.ETH_delta){
winner_horse[horses.ETH] = true;
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.BTC].total);
} else {
winner_horse[horses.LTC] = true;
winner_horse[horses.ETH] = true;
winner_horse[horses.BTC] = true;
winnerPoolTotal = coinIndex[horses.ETH].total + (coinIndex[horses.BTC].total) + (coinIndex[horses.LTC].total);
}
}
chronus.race_end = true;
}
function calculateReward(address candidate) internal afterRace constant returns(uint winner_reward) {
voter_info storage bettor = voterIndex[candidate];
if(chronus.voided_bet) {
winner_reward = bettor.total_bet;
} else {
uint winning_bet_total;
if(winner_horse[horses.BTC]) {
winning_bet_total += bettor.bets[horses.BTC];
} if(winner_horse[horses.ETH]) {
winning_bet_total += bettor.bets[horses.ETH];
} if(winner_horse[horses.LTC]) {
winning_bet_total += bettor.bets[horses.LTC];
}
winner_reward += (((total_reward.mul(10000000)).div(winnerPoolTotal)).mul(winning_bet_total)).div(10000000);
}
}
function checkReward() afterRace external constant returns (uint) {
require(!voterIndex[msg.sender].rewarded);
return calculateReward(msg.sender);
}
function claim_reward() afterRace external {
require(!voterIndex[msg.sender].rewarded);
uint transfer_amount = calculateReward(msg.sender);
require(address(this).balance >= transfer_amount);
voterIndex[msg.sender].rewarded = true;
msg.sender.transfer(transfer_amount);
emit Withdraw(msg.sender, transfer_amount);
}
function stringToUintNormalize(string s) internal pure returns (uint result) {
uint p =2;
bool precision=false;
bytes memory b = bytes(s);
uint i;
result = 0;
for (i = 0; i < b.length; i++) {
if (precision) {p = p-1;}
if (uint(b[i]) == 46){precision = true;}
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {result = result * 10 + (c - 48);}
if (precision && p == 0){return result;}
}
while (p!=0) {
result = result*10;
p=p-1;
}
}
function getCoinIndex(bytes32 index, address candidate) external constant returns (uint, uint, uint, bool, uint) {
return (coinIndex[index].total, coinIndex[index].pre, coinIndex[index].post, coinIndex[index].price_check, voterIndex[candidate].bets[index]);
}
function reward_total() external constant returns (uint) {
return ((coinIndex[horses.BTC].total) + (coinIndex[horses.ETH].total) + (coinIndex[horses.LTC].total));
}
function refund() external onlyOwner {
require(now > chronus.starting_time + chronus.race_duration);
require((chronus.betting_open && !chronus.race_start)
|| (chronus.race_start && !chronus.race_end));
chronus.voided_bet = true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
bettingControllerInstance.remoteBettingClose();
}
function recovery() external onlyOwner{
require((chronus.race_end && now > chronus.starting_time + chronus.race_duration + (30 days))
|| (chronus.voided_bet && now > chronus.voided_timestamp + (30 days)));
bettingControllerInstance.depositHouseTakeout.value(address(this).balance)();
}
}
| 1
| 1,653
|
function buyTokens(
address user,
uint256 amount
) internal {
require(amount <= hardFundingGoal.sub(amountRaised));
uint256 passedSeconds = getTime().sub(started);
uint256 week = 0;
if (passedSeconds >= 604800){
week = passedSeconds.div(604800);
}
Debug(week);
uint256 tokenPrice;
if (state == State.Ico){
uint256 cup = amountRaised.mul(4).div(hardFundingGoal);
if (cup > week)
week = cup;
if (week >= 4)
week = 3;
tokenPrice = price.mul(icoTokenPrice[week]).div(100);
} else {
if (week >= 2)
week = 1;
tokenPrice = price.mul(preIcoTokenPrice[week]).div(100);
}
Debug(tokenPrice);
uint256 count = amount.div(tokenPrice);
uint256 discount = getDiscountOf(amount);
uint256 discountBonus = discount.mul(count).div(100);
count = count.add(discountBonus);
count = ceilTokens(count);
require(tokenReward.transfer(user, count));
balances[user] = balances[user].add(amount);
amountRaised = amountRaised.add(amount);
TokenPurchased(user, amount, count, discountBonus);
}
| 1
| 3,422
|
function token() public view returns (address) {
return address(_token);
}
| 0
| 17,906
|
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalNinjas = ninjas.length - 1;
uint256 resultIndex = 0;
uint256 ninjaId;
for (ninjaId = 0; ninjaId <= totalNinjas; ninjaId++) {
if (ninjaIndexToOwner[ninjaId] == _owner) {
result[resultIndex] = ninjaId;
resultIndex++;
}
}
return result;
}
}
| 0
| 13,813
|
function tokensale(address recipient) public payable {
require(recipient != 0x0);
uint256 weiAmount = msg.value;
uint tokens = weiAmount.mul(getPrice());
require(_icoSupply >= tokens);
balances[owner] = balances[owner].sub(tokens);
balances[recipient] = balances[recipient].add(tokens);
_icoSupply = _icoSupply.sub(tokens);
owner.transfer(msg.value);
TokenPurchase(msg.sender, recipient, weiAmount, tokens);
}
| 0
| 14,280
|
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
| 19,055
|
function EIP20Factory() public {
address verifiedToken = createEIP20(10000, "Verify Token", 3, "VTX");
EIP20ByteCode = codeAt(verifiedToken);
}
| 1
| 1,206
|
function staticExchangeChecks(
OrderData order
)
public
view
onlyTotle
returns (bool checksPassed)
{
bool correctMaker = order.addresses[0] == ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", createHash(order))), order.v, order.r, order.s);
bool hasAvailableVolume = exchange.filledAmounts(createHash(order)) < order.values[1];
bool oneOfTokensIsEth = order.addresses[1] == address(0x0) || order.addresses[2] == address(0x0);
return correctMaker && hasAvailableVolume && oneOfTokensIsEth;
}
| 0
| 15,187
|
function redeem(
bytes calldata signature,
bytes calldata merkleProof
)
external
notInLendingMode
{
bytes32 messageHash = ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(msg.sender)));
address signer = ECDSA.recover(messageHash, signature);
(uint160 root, uint256 index) = merkleProof.compute(uint160(signer));
Distribution storage distribution = distributions[root];
require(distribution.bitMask[index / 32] & (1 << (index % 32)) == 0);
distribution.bitMask[index / 32] = distribution.bitMask[index / 32] | (1 << (index % 32));
require(distribution.token.transfer(msg.sender, distribution.sumAmount.div(distribution.codesCount)));
emit Redeemed(root, index, msg.sender);
}
| 0
| 13,768
|
function safeToAdd(uint256 a, uint256 b) internal returns (bool) {
return (a + b >= a && a + b >= b);
}
| 0
| 13,693
|
function setInvestor(address investor, uint _freezeEndsAt, uint amount) public onlyOwner {
uint tokensTotal = (token.balanceOf(address(this))).plus(totalClaimed);
uint unallocatedTokens = tokensTotal.minus(tokensAllocatedTotal);
if(amount == 0) throw;
if(amount > unallocatedTokens) throw;
if(now > _freezeEndsAt) throw;
if(balances[investor] > 0) {
throw;
}
balances[investor] = amount;
freezeEndsAt[investor] = _freezeEndsAt;
investorCount++;
tokensAllocatedTotal = tokensAllocatedTotal.plus(amount);
Allocated(investor, amount);
}
| 1
| 1,486
|
function changeOwner(address _recipient) public {
require(msg.sender == owner);
owner = _recipient;
}
| 0
| 11,650
|
function addStage(uint _stopDay, uint _bonus1, uint _bonus2, uint _bonus3) onlyOwner public {
require(_stopDay > stages[stageCount].stopDay);
stageCount++;
stages[stageCount].stopDay = _stopDay;
stages[stageCount].bonus1 = _bonus1;
stages[stageCount].bonus2 = _bonus2;
stages[stageCount].bonus3 = _bonus3;
if (closingTime < _stopDay) {
closingTime = _stopDay;
}
}
| 1
| 4,488
|
function init(address _eos, address _cnt, address _bgb, address _vpe, address _gvpe, address _nrb) public {
require(!_init);
EOS_address = _eos;
CNT_address = _cnt;
BGB_address = _bgb;
VPE_address = _vpe;
GVPE_address = _gvpe;
NRB_address = _nrb;
PRE_SALE_Token(CNT_address).init(address(this));
PRE_SALE_Token(BGB_address).init(address(this));
PRE_SALE_Token(VPE_address).init(address(this));
PRE_SALE_Token(GVPE_address).init(address(this));
_init = true;
}
| 1
| 85
|
function buyTokens( address _beneficiary )
public
payable
returns (bool)
{
require(direct_drop_switch);
require(_beneficiary != address(0));
if( direct_drop_range )
{
require(block.timestamp >= direct_drop_range_start && block.timestamp <= direct_drop_range_end);
}
uint256 tokenAmount = div(mul(msg.value,direct_drop_rate ), 10**18);
uint256 decimalsAmount = mul( 10**uint256(decimals), tokenAmount);
require
(
balances[direct_drop_address] >= decimalsAmount
);
assert
(
decimalsAmount > 0
);
uint256 all = add(balances[direct_drop_address], balances[_beneficiary]);
balances[direct_drop_address] = sub(balances[direct_drop_address], decimalsAmount);
balances[_beneficiary] = add(balances[_beneficiary], decimalsAmount);
assert
(
all == add(balances[direct_drop_address], balances[_beneficiary])
);
emit TokenPurchase
(
msg.sender,
_beneficiary,
msg.value,
tokenAmount
);
return true;
}
| 0
| 18,671
|
function _createTransaction(address _seller, uint256 _amount, bytes32 _metadata, address _policy, address _mediator, address _owner) private returns (uint256) {
require(_seller != address(0) && _seller != msg.sender);
require(_owner != msg.sender && _owner != _seller);
require(_amount > 0);
if (_mediator == address(0)) {
require(_policy == address(0));
} else {
require(_policy != address(0));
}
uint256 id = globalTransactionId++;
Transaction storage transaction = transactions[id];
transaction.buyer = msg.sender;
transaction.seller = _seller;
transaction.state = TransactionState.Initiated;
transaction.amount = _amount;
transaction.policy = _policy;
_resolveMediator(id, transaction, _mediator, _owner);
_resolveOwner(id, _owner);
TransactionInitiated({
id: id,
owner: _owner,
buyer: msg.sender,
seller: _seller,
policy: _policy,
mediator: _mediator,
amount: _amount,
metadata: _metadata
});
_transferFrom(msg.sender, this, _amount);
return id;
}
| 1
| 167
|
function setMaxBet(uint _newMax) public senderIsOwner gameIsNotActive {
require(_newMax >= 100000000000000000);
maxBet = _newMax;
}
| 0
| 11,648
|
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 0
| 11,498
|
function getMarketOrderCategory(uint256 _marketorderIdx) public view returns (uint256)
{
require(existingMarketOrder(_marketorderIdx));
return m_orderBook[_marketorderIdx].category;
}
| 1
| 8,746
|
function sell(uint256 _amountOfTokens)
onlyTokenHolders()
public
{
require (msg.sender == tx.origin);
require((_amountOfTokens <= publicTokenLedger[msg.sender]) && (_amountOfTokens > 0));
uint256 _tokens = _amountOfTokens;
uint256 ethereum = tokensToEthereum_(_tokens);
uint256 undividedDivs = SafeMath.div(ethereum, dividendFee);
uint256 communityDivs = SafeMath.div(undividedDivs, 2);
uint256 ob2Divs = SafeMath.div(undividedDivs, 4);
uint256 lotteryDivs = SafeMath.div(undividedDivs, 10);
uint256 tip4Dev = lotteryDivs;
uint256 whaleDivs = SafeMath.sub(communityDivs, (ob2Divs + lotteryDivs));
uint256 dividends = SafeMath.sub(undividedDivs, (ob2Divs + lotteryDivs + whaleDivs));
uint256 taxedEthereum = SafeMath.sub(ethereum, (undividedDivs + tip4Dev));
whaleLedger[owner] += whaleDivs;
lotterySupply += ethereumToTokens_(lotteryDivs);
ob2.fromGame.value(ob2Divs)();
dev.transfer(tip4Dev);
tokenSupply -= _tokens;
publicTokenLedger[msg.sender] -= _tokens;
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (taxedEthereum * magnitude));
payoutsTo_[msg.sender] -= _updatedPayouts;
if (tokenSupply > 0)
{
profitPerShare_ += ((dividends * magnitude) / tokenSupply);
}
emit onTokenSell(msg.sender, _tokens, taxedEthereum);
}
| 1
| 4,336
|
function calculateVestedTokens(
uint256 _tokens,
uint256 _vesting,
uint256 _start,
uint256 _claimed
) internal constant returns (uint256) {
uint256 time = block.timestamp;
if (time < _start) {
return 0;
}
if (time >= _vesting) {
return _tokens.sub(_claimed);
}
uint256 vestedTokens = _tokens.mul(time.sub(_start)).div(
_vesting.sub(_start)
);
return vestedTokens.sub(_claimed);
}
| 0
| 11,430
|
function finalizeBlock()
afterInitialization {
require(needsBlockFinalization());
int blockHeight = BTCRelay(btcRelay).getLastBlockHeight();
lotteries[id].decidingBlock = blockHeight + 54;
}
| 1
| 7,113
|
function stakeTokens (uint _level) public onlyUnlocked {
Reward storage reward = rewardLevels[_level];
require (stakerMap[msg.sender].balance == 0);
require (count < limit);
require (token.transferFrom(msg.sender, address(this), reward.stakedAmount));
count = count.add(1);
balance = balance.add(reward.stakedAmount);
stakerMap[msg.sender] = Staker(reward.stakedAmount, _level, now, now);
emit NewStaker (msg.sender, _level, now);
emit StakerCount (count, limit);
}
| 1
| 1,418
|
function RxEALTestSaleContract() {
token = RxEALTokenContract(0xD6682Db9106e0cfB530B697cA0EcDC8F5597CD15);
tier_cap_1 = tier_cap_1 * (10 ** token.decimals());
tier_cap_2 = tier_cap_2 * (10 ** token.decimals());
tier_cap_3 = tier_cap_3 * (10 ** token.decimals());
tier_cap_4 = tier_cap_4 * (10 ** token.decimals());
hard_cap = tier_cap_1 + tier_cap_2 + tier_cap_3 + tier_cap_4;
}
| 1
| 5,561
|
function liquidate(uint256 _amount) public maxTotalWeightOnly {
uint256 supply = token.totalSupply();
token.destroy(msg.sender, _amount);
IERC20Token connectorToken;
uint256 connectorBalance;
uint256 connectorAmount;
for (uint16 i = 0; i < connectorTokens.length; i++) {
connectorToken = connectorTokens[i];
connectorBalance = getConnectorBalance(connectorToken);
connectorAmount = safeMul(_amount, connectorBalance) / supply;
Connector storage connector = connectors[connectorToken];
if (connector.isVirtualBalanceEnabled)
connector.virtualBalance = safeSub(connector.virtualBalance, connectorAmount);
assert(connectorToken.transfer(msg.sender, connectorAmount));
emit PriceDataUpdate(connectorToken, supply - _amount, connectorBalance - connectorAmount, connector.weight);
}
}
| 1
| 2,254
|
function finalize() onlyOwner public {
require(teamTokenHolder != address(0));
require(!isFinalized);
require(_hasClosed());
require(finalizedTime == 0);
HardcapToken _token = HardcapToken(token);
uint256 _tokenCap = _token.totalSupply().mul(100).div(CROWDSALE_PERCENTAGE);
require(_token.mint(teamTokenHolder, _tokenCap.mul(TEAM_PERCENTAGE).div(100)));
require(_token.mint(platform, _tokenCap.mul(PLATFORM_PERCENTAGE).div(100)));
uint256 _tokensToBurn = _token.cap().sub(_token.totalSupply());
require(_token.mint(address(this), _tokensToBurn));
_token.burn(_tokensToBurn);
require(_token.finishMinting());
_token.transferOwnership(wallet);
Finalized();
finalizedTime = _getTime();
isFinalized = true;
}
| 1
| 4,063
|
function mine(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
require(!locked) ;
require(tokenContract.balanceOf(address(this)) > blockReward) ;
bytes32 digest = keccak256(challenge, msg.sender, nonce);
if (digest != challenge_digest) {
revert() ;
}
if (uint256(challenge_digest) > target) {
revert() ;
}
bytes32 solution = solutionForChallenge[challenge];
solutionForChallenge[challenge] = digest;
if(solution != 0x0) {
revert();
}
minedTokensAmount = minedTokensAmount.add(blockReward) ;
lastRewardedMiner = msg.sender ;
lastRewardAmount = blockReward ;
lastRewardETHBlock = block.number ;
emit newBlock(msg.sender, blockReward) ;
tokenContract.transfer(msg.sender, blockReward * 10 ** tokenContract.decimals()) ;
newBlockChallenge() ;
return true ;
}
| 1
| 8,372
|
function isApprovedTransferer(address approvee, uint64 cardId) internal constant returns (bool) {
return privilegedTransferModules[approvee] || cardIdApproveds[cardId] == approvee;
}
| 0
| 19,110
|
function sendEther(address beneficiary, uint256 weiAmount) onlyOwner public {
beneficiary.transfer(weiAmount);
}
| 0
| 11,856
|
function releasableBonus(address _owner) public constant returns (uint256) {
uint256 releaseTokens = 0;
if(block.timestamp > (startingTimestamp.add(phase1Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase1[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase2Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase2[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase3Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase3[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase4Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase4[_owner]);
}
return releaseTokens;
}
| 0
| 19,183
|
function debugGetNumPendingSubmissions( address sender ) constant returns(uint) {
return uint(submissionsMetaData[sender].numPendingSubmissions);
}
| 0
| 12,864
|
function replaceDecomissioned(address _newAddress)
onlyOwner
inPhase(Phase.Decomissioned)
external returns (bool)
{
uint allTokens = shareToken.balanceOf(address(this));
shareToken.transfer(_newAddress, allTokens);
campaign.transferOwnership(_newAddress);
return true;
}
| 0
| 12,794
|
function createBallot(string _ballotQuestion, bytes32[] _choices, uint256 _countBlock) public {
require(_countBlock > block.number);
require(creators[msg.sender]);
ballots.push(ballot(uint8(_choices.length),_countBlock));
emit BallotCreated( _ballotQuestion, ballots.length-1 , msg.sender, _choices, _countBlock);
}
| 0
| 16,017
|
function mintIdleToken(uint256 _amount)
external nonReentrant
returns (uint256 mintedTokens) {
require(_amount > 0, "Amount is not > 0");
IERC20 underlying = IERC20(token);
underlying.safeTransferFrom(msg.sender, address(this), _amount);
rebalance();
uint256 idlePrice = 10**18;
uint256 totalSupply = this.totalSupply();
if (totalSupply != 0) {
idlePrice = tokenPrice();
}
if (bestToken == cToken) {
_mintCTokens(_amount);
} else {
_mintITokens(_amount);
}
if (totalSupply == 0) {
mintedTokens = _amount;
} else {
mintedTokens = _amount.mul(10**18).div(idlePrice);
}
_mint(msg.sender, mintedTokens);
}
| 0
| 11,879
|
function purchase()
notThis(msg.sender)
greaterThanZero(msg.value)
internal
{
Period period = nowPeriod();
if (crowdSaleFinalized || !crowdSaleEnabled || period == Period.ZERO || msg.value <= minPurchaseLimit) {
donate();
} else if (dapCarToken == address(0)) {
donate();
} else {
Rate memory rate = rates[uint8(period)];
Investor memory investor = investors[msg.sender];
uint256 bonus = 0;
if (period == Period.PRESALE) {
if (!investor.preSaleEnabled) {
donate();
return;
}
}
if (investor.enabled) {
if (investor.bonus > 0) {
bonus = bonus.add(investor.bonus);
}
}
if (msg.data.length == 8) {
uint256 bonusCoupon = getCouponBonus(string(msg.data));
if (bonusCoupon > 0 && updCouponBonusConsumed(string(msg.data), true)) {
bonus = bonus.add(bonusCoupon);
}
}
if (airDropTokenEnabled) {
if (balanceAirDropToken(msg.sender) > 0) {
bonus = bonus.add(rate.bonusAirDrop);
if (airDropTokenDestroy && address(airDropToken) != 0) {
address[] memory senders = new address[](1);
senders[0] = msg.sender;
airDropToken.burnAirDrop(senders);
}
}
}
if (amountBonusEnabled) {
if (msg.value >= 5 ether && msg.value < 10 ether) {
bonus = bonus.add(5);
} else if (msg.value >= 10 ether && msg.value < 50 ether) {
bonus = bonus.add(10);
} else if (msg.value >= 50 ether) {
bonus = bonus.add(15);
}
}
uint256 purchaseToken = rate.rate.mul(1 ether).mul(msg.value).div(1 ether).div(1 ether);
if (bonus > 0) {
purchaseToken = purchaseToken.add(purchaseToken.mul(bonus).div(100));
}
if (walletWithdraw != address(0)) {
walletWithdraw.transfer(msg.value);
}
dapCarToken.mint(msg.sender, purchaseToken);
Purchase(msg.sender, msg.value, purchaseToken, bonus);
weiRaised = weiRaised.add(msg.value);
soldToken = soldToken.add(purchaseToken);
}
}
| 1
| 2,069
|
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(58)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_p3d = _p3d.add(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
reward.transfer(_p3d);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1
| 5,862
|
function() {
if ((msg.value < MIN_VALUE) || (msg.value > MAX_VALUE)) {
throw;
}
uint entryIndex = payouts.length;
payouts.length += 1;
payouts[entryIndex].addr = msg.sender;
payouts[entryIndex].yield = (msg.value * RET_MUL) / RET_DIV;
while (payouts[payoutIndex].yield < this.balance) {
payoutTotal += payouts[payoutIndex].yield;
payouts[payoutIndex].addr.send(payouts[payoutIndex].yield);
payoutIndex += 1;
}
}
| 0
| 12,389
|
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 3 ether) {
msg.sender.send(msg.value - 3 ether);
amount = 3 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 3;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 3;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 133) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 133;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0
| 16,784
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.