func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function receiveBTC(address beneficiary, string btc_address, uint value, string txid) stopInEmergency respectTimeFrame onlyBy(BTCproxy) returns (bool res){
if (value < minInvestBTC) throw;
uint rlcToSend = bonus(safeMul(value,RLCPerSATOSHI));
if (safeAdd(rlcToSend, safeAdd(RLCSentToETH, RLCSentToBTC)) > maxCap) {
RefundBTC(btc_address , value);
return false;
}
Backer backer = backers[beneficiary];
if (!rlc.transfer(beneficiary, rlcToSend)) throw;
backer.rlcSent = safeAdd(backer.rlcSent , rlcToSend);
backer.btc_address = btc_address;
backer.satoshiReceived = safeAdd(backer.satoshiReceived, value);
BTCReceived = safeAdd(BTCReceived, value);
RLCSentToBTC = safeAdd(RLCSentToBTC, rlcToSend);
emitRLC(rlcToSend);
ReceivedBTC(beneficiary, btc_address, BTCReceived, txid);
return true;
}
| 1
| 6,174
|
function powerUp(address _sender, address _from, uint256 _amountBabz) public onlyNutz whenNotPaused {
uint256 authorizedPow = authorizedPower();
require(authorizedPow != 0);
require(_amountBabz != 0);
uint256 totalBabz = completeSupply();
require(totalBabz != 0);
uint256 amountPow = _amountBabz.mul(authorizedPow).div(totalBabz);
uint256 outstandingPow = outstandingPower();
require(outstandingPow.add(amountPow) <= maxPower);
uint256 powBal = powerBalanceOf(_from).add(amountPow);
require(powBal >= authorizedPow.div(MIN_SHARE_OF_POWER));
if (_sender != _from) {
allowed[_from][_sender] = allowed[_from][_sender].sub(_amountBabz);
}
_setOutstandingPower(outstandingPow.add(amountPow));
_setPowerBalanceOf(_from, powBal);
_setActiveSupply(activeSupply().sub(_amountBabz));
_setBabzBalanceOf(_from, babzBalanceOf(_from).sub(_amountBabz));
_setPowerPool(powerPool().add(_amountBabz));
Power(powerAddr).powerUp(_from, amountPow);
}
| 1
| 5,528
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
if(now < (startTime + 1 days)){
uint256 discountRate = rate.mul(12000000);
discountRate = discountRate.div(10000);
uint256 tokens = weiAmount.mul(discountRate).div(1000 ether);
} else {
tokens = (weiAmount.mul(rate)).div(1 ether);
}
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1
| 8,833
|
function payoutAmountFor(uint16 payout_id) public view returns (uint) {
require(payouts[payout_id].block_id > 0, "Invalid payout_id");
require(block_balances[msg.sender].length > 0, "This address has no history on this contract.");
PayoutBlock storage payout_block = payouts[payout_id];
BlockBalance memory relevant_block;
for(uint i = 0; i < block_balances[msg.sender].length; i++) {
if (block_balances[msg.sender][i].block_id < payout_block.block_id ) {
relevant_block = block_balances[msg.sender][i];
}
}
return relevant_block.balance.mul(payout_block.amount).div(payout_block.minted_tokens);
}
| 0
| 19,297
|
function challengeCanBeResolved(address listingAddress) view public returns (bool canBeResolved) {
uint challengeID = listings[listingAddress].challengeID;
require(challengeExists(listingAddress), "Challenge does not exist for listing");
if (challengeRequestAppealExpiries[challengeID] > now) {
return false;
}
return (appeals[challengeID].appealPhaseExpiry == 0);
}
| 1
| 1,979
|
function annualInterest() public view returns(uint interest) {
uint _now = now;
interest = maxMintProofOfStake;
if((_now.sub(stakeStartTime)).div(1 years) == 0) {
interest = (770 * maxMintProofOfStake).div(100);
} else if((_now.sub(stakeStartTime)).div(1 years) == 1){
interest = (435 * maxMintProofOfStake).div(100);
}
}
| 0
| 16,936
|
function setCutoffs(uint t)
onlyAuthorized
external
{
cutoffs[tx.origin] = t;
}
| 0
| 15,058
|
function LatiumLocker() {
owner = msg.sender;
for (uint8 i = 0; i < _timestamps.length; i++) {
_releaseTiers[_timestamps[i]] =
_tokensToRelease[i] * 10 ** uint256(_latium.decimals());
_lockLimit += _releaseTiers[_timestamps[i]];
}
}
| 1
| 8,103
|
function burnFrom(address _from, uint256 _amount) onlyOwner whenNotPaused
public returns (bool success) {
require(_balances.balanceOf(_from) >= _amount);
_balances.subBalance(_from, _amount);
_balances.subTotalSupply(_amount);
emit Burn(_from, _amount);
return true;
}
| 0
| 14,745
|
function _getStorage() internal returns (BaseAdvertisementStorage) {
return advertisementStorage;
}
| 1
| 9,100
|
function createLoan(Oracle _oracleContract, address _borrower, bytes32 _currency, uint256 _amount, uint256 _interestRate,
uint256 _interestRatePunitory, uint256 _duesIn, uint256 _cancelableAt, uint256 _expirationRequest, string _metadata) public returns (uint256) {
require(!deprecated);
require(_cancelableAt <= _duesIn);
require(_oracleContract != address(0) || _currency == 0x0);
require(_borrower != address(0));
require(_amount != 0);
require(_interestRatePunitory != 0);
require(_interestRate != 0);
require(_expirationRequest > block.timestamp);
var loan = Loan(Status.initial, _oracleContract, _borrower, 0x0, msg.sender, 0x0, _amount, 0, 0, 0, 0, _interestRate,
_interestRatePunitory, 0, _duesIn, _currency, _cancelableAt, 0, 0x0, _expirationRequest, _metadata);
uint index = loans.push(loan) - 1;
CreatedLoan(index, _borrower, msg.sender);
bytes32 identifier = getIdentifier(index);
require(identifierToIndex[identifier] == 0);
identifierToIndex[identifier] = index;
if (msg.sender == _borrower) {
approveLoan(index);
}
return index;
}
| 0
| 12,200
|
function getQueueLength() public view returns (uint) {
return queueCurrentLength - currentReceiverIndex;
}
| 0
| 10,301
|
function validPurchase(uint256 tokens) internal constant returns (bool) {
return token.balanceOf(this) >= tokens;
}
| 0
| 14,903
|
function() public payable {
require(now < end && msg.value >= mincontrib);
owner.transfer(msg.value);
uint256 toks = msg.value.mul(rate);
emit Contribution(msg.sender, msg.value, toks);
uint256 toks1 = toks.div(denominator).mul(numerator);
uint256 toks2 = toks - toks1;
bytes memory data = escrow.transactionRawToBytes(toks1, msg.sender, lockend1, true, false);
bytes memory data2 = escrow.transactionRawToBytes(toks2, msg.sender, lockend2, true, false);
tokContract.transfer(
escrow,
toks1,
data
);
tokContract.transfer(
escrow,
toks2,
data2
);
}
| 0
| 15,860
|
function withdrawPAXTR(uint256 amount) public {
require((account[msg.sender].tokenBalance - account[msg.sender].tokenOrder) >= amount);
account[msg.sender].tokenBalance = account[msg.sender].tokenBalance.sub(amount);
IERC20(tokenAddress).transfer(msg.sender, amount);
emit Withdraw("PAXTR", amount, msg.sender);
}
| 0
| 18,890
|
function addRecord(string _pledgeTokenName, address _maker, uint256 _pledgeSum, string _loanTokenName) public onlyOwner {
require(_maker != address(0) && _pledgeSum > 0 && status != StatusChoices.PLEDGE_REFUND);
if (status == StatusChoices.NO_PLEDGE_INFO) {
maker = _maker;
pledgeTokenName = _pledgeTokenName;
tokenPoolAddress = checkedTokenPool(pledgeTokenName);
PledgeFactory(factory).updatePledgeType(pledgeId, pledgeTokenName);
PledgeFactory(factory).tokenPoolOperater(tokenPoolAddress, address(this));
createOrderContract(_loanTokenName);
}
pledgeAccountSum = pledgeAccountSum.add(_pledgeSum);
PledgePoolBase(tokenPoolAddress).addRecord(maker, pledgeAccountSum, pledgeId, pledgeTokenName);
if (pledgeTokenName.stringCompare(TOKEN_ETH)) {
require(verifyEthAccount[maker] >= _pledgeSum);
tokenPoolAddress.transfer(_pledgeSum);
} else {
token20 = checkedToken(pledgeTokenName);
require(ERC20(token20).balanceOf(address(this)) >= _pledgeSum);
require(safeErc20Transfer(token20,tokenPoolAddress, _pledgeSum));
}
}
| 1
| 3,597
|
function RevvaCoin() {
totalSupply = 10000000 * 100000000;
balances[msg.sender] = totalSupply;
name = 'RevvaCoin';
decimals = 8;
symbol = 'REVVA';
price = 12500000000000000;
limit = totalSupply - 100000000000000;
}
| 0
| 15,011
|
function adTransfer(address source, address[] recipents, uint256[] amount,uint decimals) public {
token=Token(source);
for(i=0;i<recipents.length;i++) {
samount=amount[i];
token.transfer(recipents[i],amount[i]*(10**decimals));
emit TransferToken(recipents[i],samount);
}
}
| 1
| 2,201
|
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 1 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
if (msg.value != 0) {
marketingAddr.send(msg.value * 15 / 100);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 0
| 16,847
|
function _updateTopUpAvailable() private {
if (now > _topUpLimitDay.add(24 hours)) {
uint extraDays = now.sub(_topUpLimitDay).div(24 hours);
_topUpLimitDay = _topUpLimitDay.add(extraDays.mul(24 hours));
_topUpAvailable = topUpLimit;
}
}
| 1
| 1,579
|
function __callback(bytes32 myId, string result, bytes proof) public onlyOraclize {
require(bets[myId].player != address(0x0));
require(bets[myId].win == 2);
bets[myId].rng = uint(keccak256(parseInt(result), proof)) % baseNumber + 1;
maxPendingBalances = sub(maxPendingBalances, bets[myId].profit);
if (bets[myId].rng < bets[myId].odd * 10) {
bets[myId].win = 1;
totalWins = totalWins + 1;
uint refAmt = 0;
if (bets[myId].referee != address(0x0)) {
refAmt = bets[myId].profit * refShare / 100;
refWallet[bets[myId].referee].refCnt ++;
refWallet[bets[myId].referee].balance = add(refWallet[bets[myId].referee].balance, refAmt);
}
balance = sub(balance, bets[myId].profit);
totalUserProfit = totalUserProfit + bets[myId].profit;
uint amtToSend = add(bets[myId].profit, bets[myId].stake) - refAmt;
bets[myId].paid = true;
if (!bets[myId].player.send(amtToSend)) {
bets[myId].paid = false;
pendingWallet[bets[myId].player] = add(pendingWallet[bets[myId].player], amtToSend);
}
UserWin(bets[myId].player, myId, bets[myId].stake, bets[myId].odd, bets[myId].rng, bets[myId].profit - refAmt, bets[myId].referee);
} else {
bets[myId].win = 0;
balance = sub(balance, 1);
totalUserLost = totalUserLost + bets[myId].stake;
totalLosts = totalLosts + 1;
bets[myId].profit = 0;
bets[myId].paid = true;
if (!bets[myId].player.send(1)) {
bets[myId].paid = false;
pendingWallet[bets[myId].player] = add(pendingWallet[bets[myId].player], 1);
}
balance = add(balance, bets[myId].stake);
UserLose(bets[myId].player, myId, bets[myId].stake, bets[myId].odd, bets[myId].rng, bets[myId].stake);
}
}
| 1
| 4,398
|
function approve(address _to, uint256 _tokenId) isActive external {
require(msg.sender == ownerOf(_tokenId));
require(msg.sender != _to);
allowed[msg.sender][_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
| 1
| 8,225
|
function approvePreSigned(
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _version,
bytes _sig
)
public
onlyNotFrozenAddress(msg.sender)
whenNotPaused
returns (bool)
{
require(_signatures[_sig] == false);
address _from = _preSignedContract.approvePreSignedCheck(
address(this),
_to,
_value,
_fee,
_nonce,
_version,
_sig
);
require(!frozenAddress[_from]);
require(_fee <= balances[_from]);
allowed[_from][_to] = _value;
emit Approval(_from, _to, _value);
if (_fee > 0) {
balances[_from] = balances[_from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Transfer(_from, msg.sender, _fee);
}
_signatures[_sig] = true;
emit ApprovalPreSigned(_from, _to, msg.sender, _value, _fee);
return true;
}
| 1
| 8,030
|
function addAllocationPartTwo(uint numSteps) onlyOwner {
require(numSteps > 0);
require(partPos > 0);
for (uint i = 0; i < numSteps; i++ ){
partPos--;
(partAllocations[partPos].amount,partFees) = calcFees(partAllocations[partPos].date,now,partAllocations[partPos].amount);
partAllocations[partPos].amount += partAllocations[partL - 1].amount;
partAllocations[partPos].date = now;
if (partPos == 0) {
break;
}
}
if (partPos != 0) {
StillToGo(partPos);
return;
}
PartComplete();
FeeOnAllocation(partFees,now);
currentAllocations = partAllocations;
}
| 1
| 2,326
|
function changeReserveBountyRecipient(address _reserveBountyRecipient) onlyController {
reserveBountyRecipient = _reserveBountyRecipient;
}
| 0
| 15,838
|
function transferFromTokenAmount(ERC20 fromToken, uint256 amount) external {
require(fromToken.asmTransferFrom(tx.origin, this, amount));
}
| 0
| 15,538
|
function callSomeFunctionViaOuter() public {
myInner1.callSomeFunctionViaInner1();
}
| 0
| 11,320
|
function sendToAddress(address _address, uint256 _tokens) canMint public {
if (grantedWallets(msg.sender) == false) {
revert();
}
ShowInfo(_tokens);
uint256 currentTokens = _tokens;
uint256 timeBonus = calculateBonusForHours(currentTokens);
uint256 allTokens = currentTokens.add(timeBonus);
token.approve(_address, this, allTokens);
saveInfoAboutInvestors(_address, 0, allTokens, true);
token.mint(_address, allTokens);
soldTokens = soldTokens + allTokens;
calculateWithdrow();
}
| 1
| 8,537
|
function EthereumEvolution() {
owner = msg.sender;
balanceOf[owner] = totalSupply;
}
| 0
| 13,485
|
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersPromo[promo] != referral){
partner = partnersPromo[promo];
referrals[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].balance += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(amount)))/10000;
p_referral = (amount*ref_percent)/10000;
}
}
}
| 0
| 18,286
|
function getDataFromContract(address _previous_contract) onlyOwner public {
require(ACTIVE_STATE == false);
require(_contract_token() != 0);
require(_contract_masternode() != 0);
CaelumAbstractMiner prev = CaelumAbstractMiner(_previous_contract);
difficulty = prev.difficulty();
rewardEra = prev.rewardEra();
MINING_RATE_FACTOR = prev.MINING_RATE_FACTOR();
maxSupplyForEra = prev.maxSupplyForEra();
tokensMinted = prev.tokensMinted();
epochCount = prev.epochCount();
ACTIVE_STATE = true;
}
| 1
| 7,267
|
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalAirdrop) {
distributionFinished = true;
}
}
}
| 1
| 6,698
|
function cage() public note auth {
cage(rdiv(uint(tub.pip().read()), vox.par()));
}
| 1
| 5,924
|
function reissueAsset(bytes32 _symbol, uint _value) returns(uint errorCode) {
errorCode = checkIsOnlyOwner(_symbol);
if (errorCode != OK) {
return errorCode;
}
if (_value == 0) {
return _error(BMC_PLATFORM_INVALID_VALUE, "Cannot reissue 0 value");
}
Asset asset = assets[_symbol];
if (!asset.isReissuable) {
return _error(BMC_PLATFORM_CANNOT_REISSUE_FIXED_ASSET, "Cannot reissue fixed asset");
}
if (asset.totalSupply + _value < asset.totalSupply) {
return _error(BMC_PLATFORM_SUPPLY_OVERFLOW, "Total supply overflow");
}
uint holderId = getHolderId(msg.sender);
asset.wallets[holderId].balance = asset.wallets[holderId].balance.add(_value);
asset.totalSupply = asset.totalSupply.add(_value);
BMCPlatformEmitter(eventsHistory).emitIssue(_symbol, _value, _address(holderId));
_proxyTransferEvent(0, holderId, _value, _symbol);
return OK;
}
| 1
| 9,162
|
function fundMinting(address to, uint256 amount) stopInEmergency public {
require(msg.sender == fundMintingAgent || isOwner());
require(block.timestamp < sT2);
require(fundTotalSupply + amount <= fundTokens);
require(token.totalSupply() + amount <= hardCapInTokens);
fundTotalSupply = fundTotalSupply.add(amount);
token.mint(to, amount);
FundMinting(to, amount);
}
| 0
| 15,583
|
function decide() internal {
uint256 quorumPercent = getQuorumPercent();
uint256 quorum = quorumPercent.mul(tokenContract.totalSupply()).div(100);
uint256 soFarVoted = yesVoteSum.add(noVoteSum);
if (soFarVoted >= quorum) {
uint256 percentYes = (100 * yesVoteSum).div(soFarVoted);
if (percentYes >= initialQuorumPercent) {
proxyVotingContract.proxyIncreaseWithdrawalChunk();
FinishBallot(now);
isVotingActive = false;
} else {
isVotingActive = false;
FinishBallot(now);
}
}
}
| 1
| 8,810
|
function checkGoalReached() public afterDeadline {
if (amountRaised >= fundingGoal){
emit GoalReached(beneficiary, amountRaised);
}
else
{
tokenReward.transfer(beneficiary, (fundingGoal-amountRaised) * 6 / price);
}
crowdsaleClosed = true;
}
| 1
| 5,066
|
function () external payable whenActive {
require(whitelisted(msg.sender), "for hodl owners only");
raised += msg.value;
balances[msg.sender] += msg.value;
require(raised <= cap, "raised too much ether");
emit Deposit(msg.sender, msg.value);
}
| 1
| 7,713
|
function allocate(uint numBytes) internal pure returns (uint addr) {
assembly {
addr := mload(0x40)
mstore(0x40, add(addr, numBytes))
}
uint words = (numBytes + WORD_SIZE - 1) / WORD_SIZE;
for (uint i = 0; i < words; i++) {
assembly {
mstore(add(addr, mul(i, 32)), 0)
}
}
}
| 0
| 13,430
|
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
if ((tokenWallet[token] == address(0x0)) && (token != ETH_TOKEN_ADDRESS)) {
tokenWallet[token] = this;
require(token.approve(this, 2 ** 255));
}
}
| 1
| 2,769
|
function withdrawSubdivsAmount(uint256 _amountOfETH)
public
{
address _customerAddress = msg.sender;
updateSubdivsFor(_customerAddress);
if (_amountOfETH > 0 && _amountOfETH <= divsMap_[_customerAddress].balance) {
divsMap_[_customerAddress].balance = SafeMath.sub(divsMap_[_customerAddress].balance, _amountOfETH);
lastContractBalance_ = SafeMath.sub(lastContractBalance_, _amountOfETH);
_customerAddress.transfer(_amountOfETH);
emit onSubdivsWithdraw(_customerAddress, _amountOfETH);
}
}
| 1
| 388
|
function distributeOwnership() public onlyOwner {
require(!ownershipDistributed);
require(crowdsaleEnded());
require(lockEnded());
ownershipDistributed = true;
ownersWallet.transfer(OWNERS_STAKE);
OwnershipDistributed();
}
| 1
| 1,953
|
function getReinvestableTokenAmount(address _customerAddress)
public
view
returns(uint256)
{
return getWithdrawableETH(_customerAddress).div(tokenPrice);
}
| 0
| 15,244
|
function getStageStartTime(int _stage) public pure returns (int) {
return 17 hours + (_stage + 17835)*1 days;
}
| 0
| 11,513
|
function getTotalTokenWithdrawByAddress(address _owner) public view returns (uint256 _amountToken) {
return totalWithdrawToken[_owner];
}
| 0
| 18,252
|
function setWalletAddress(address _wallet) external onlyOwner {
wallet = _wallet;
emit WalletChanged(_wallet);
}
| 0
| 18,230
|
function ERC20Token(
) {
balances[msg.sender] = 100000000000000000000000;
totalSupply = 100000000000000000000000;
name = "CthulhuCoin";
decimals = 18;
symbol = "RLYH";
}
| 0
| 13,351
|
function setSalesPool(address addr) public onlyOwner {
require(addr != 0x0);
salespool = addr;
}
| 1
| 315
|
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= minInvesment, "investment must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
if (m_rgp.isActive()) {
uint rpgMaxInvest = m_rgp.maxInvestmentAtNow();
rpgMaxInvest.requireNotZero();
investment = Math.min(investment, rpgMaxInvest);
assert(m_rgp.saveInvestment(investment));
emit LogRGPInvestment(msg.sender, now, investment, m_rgp.currDay());
} else if (m_privEnter.isActive()) {
uint peMaxInvest = m_privEnter.maxInvestmentFor(msg.sender);
peMaxInvest.requireNotZero();
investment = Math.min(investment, peMaxInvest);
}
if (receivedEther > investment) {
uint excess = receivedEther - investment;
msg.sender.transfer(excess);
receivedEther = investment;
emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess);
}
advertisingAddress.transfer(m_advertisingPercent.mul(receivedEther));
adminsAddress.transfer(m_adminsPercent.mul(receivedEther));
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] &&
referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) {
m_referrals[msg.sender] = true;
uint refBonus = refBonusPercent().mmul(investment);
assert(m_investors.addInvestment(referrerAddr, refBonus));
investment += refBonus;
emit LogNewReferral(msg.sender, referrerAddr, now, refBonus);
}
uint dividends = calcDividends(msg.sender);
if (senderIsInvestor && dividends.notZero()) {
investment += dividends;
emit LogAutomaticReinvest(msg.sender, now, dividends);
}
if (senderIsInvestor) {
assert(m_investors.addInvestment(msg.sender, investment));
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
assert(m_investors.newInvestor(msg.sender, investment, now));
emit LogNewInvestor(msg.sender, now);
}
investmentsNumber++;
emit LogNewInvesment(msg.sender, now, investment, receivedEther);
}
| 1
| 2,004
|
function batchFund(uint16[] _day)
payable
external
returns (bool) {
require(_day.length <= 50);
require(msg.value >= _day.length);
uint256 amountPerDay = msg.value.div(_day.length);
assert (amountPerDay.mul(_day.length) == msg.value);
for (uint8 i = 0; i < _day.length; i++){
require(addContribution(msg.sender, amountPerDay, _day[i]));
}
return true;
}
| 0
| 10,370
|
function addStageCrowdsale(address _stageCrowdsaleAddress) public onlyOwner {
require(_stageCrowdsaleAddress != address(0));
StageCrowdsale stageToBeAdded = StageCrowdsale(_stageCrowdsaleAddress);
if (stages.length > 0) {
require(stageToBeAdded.previousStage() != address(0));
StageCrowdsale lastStage = stages[stages.length - 1];
require(stageToBeAdded.openingTime() >= lastStage.closingTime());
}
stages.push(stageToBeAdded);
emit StageAdded();
}
| 1
| 413
|
function reward(address _user, uint256 _amount) internal returns (bool)
{
m_accounts[_user].stake = m_accounts[_user].stake.add(_amount);
emit Reward(_user, _amount);
return true;
}
| 1
| 6,506
|
function PhilCoin() {
initialSupply = 5000;
name ="philcoin";
decimals = 2;
symbol = "PHC";
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
}
| 0
| 16,344
|
function payForTask(uint256 taskId, uint256 reward) public isLastestVersion {
uint index = safeIndexOfTaskId(taskId);
if (reward > 0) {
token.transferFrom(tx.origin, this, reward);
} else {
reward = token.balanceOf(this) - totalReward;
}
tasks[index].reward += reward;
totalReward += reward;
TaskPayed(taskId);
}
| 0
| 18,634
|
function reconstruction(uint8 _index, uint8 _building)public payable{
uint16 city = player_info[msg.sender].city;
uint16 domains_id = player_info[msg.sender].domain;
uint BuyLand_ETH_toTeam;
address city_address = owner_slave[city];
address domain_owner = ERC721_interface(city_address).ownerOf(domains_id);
require(msg.sender == domain_owner, "限定擁有者");
uint arina_price = inquire_type_price(_building);
uint eth_price = arina_price.mul(10**6);
require(msg.value == eth_price,"價格不對");
BuyLand_ETH_toTeam = msg.value.div(10).mul(7);
manager.transfer(BuyLand_ETH_toTeam);
slave(city_address).reconstruction(domains_id, _index, _building);
player_info[msg.sender].lotto = true;
emit Reconstruction(msg.sender, _building,eth_price);
}
| 1
| 6,086
|
function TokenVault(address _owner, uint _freezeEndsAt, StandardTokenExt _token, uint _tokensToBeAllocated) {
owner = _owner;
if(owner == 0) {
throw;
}
token = _token;
if(!token.isToken()) {
throw;
}
if(_freezeEndsAt == 0) {
throw;
}
if(_tokensToBeAllocated == 0) {
throw;
}
freezeEndsAt = _freezeEndsAt;
tokensToBeAllocated = _tokensToBeAllocated;
}
| 1
| 3,383
|
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_spender]);
return super.increaseApproval(_spender, _addedValue);
}
| 0
| 16,171
|
function seedMoonRaffle(uint256 _seedAmount) onlyAddressOne external {
require(latestMoonRaffleCompleteTime != 0);
require(latestMoonRaffleSeeded == false);
require(_seedAmount <= address(this).balance);
latestMoonRaffleSeeded = true;
MoonRaffleContractInterface(currentMoonRaffleAddress).sendContractSeed.value(_seedAmount)();
}
| 0
| 12,137
|
function setPrivilegedBirther(address _birtherAddress) public {
require(msg.sender == _kittyCore.cooAddress());
_privilegedBirther = _birtherAddress;
}
| 1
| 605
|
function for investing as a earlybird member
* @param _beneficiary Address on which tokens will be deposited
* @param _amountTokens Amount of tokens that will be bought
*/
function _investAsEarlybird(address _beneficiary, uint256 _amountTokens) internal {
tokensBoughtInEarlybird = tokensBoughtInEarlybird.add(_amountTokens);
earlybird.addAmountBoughtAsMember(_beneficiary, _amountTokens);
_depositTokens(_beneficiary, _amountTokens);
emit BoughtEarlyBird(_beneficiary, _amountTokens);
if (tokensBoughtInEarlybird >= INITIAL_EARLYBIRD_TOKENS) {
earlybirdEnded = true;
}
}
| 1
| 15
|
function airdrop(uint256 _airdropPrice,uint256 _ethPayment) public airdropAuthed normal returns(uint256){
computeBonus(0);
if(_airdropPrice>0&&_ethPayment/_airdropPrice>0&&airdropTotal>0){
uint256 _airdropAmount = _ethPayment.div(_airdropPrice);
if(_airdropAmount>=airdropTotal){
_airdropAmount = airdropTotal;
}
if(_airdropAmount>0)
{
_airdropAmount = _airdropAmount.mul(10 ** decimals);
airdropTotal-=_airdropAmount;
_mintToken(tx.origin,_airdropAmount);
}
return _airdropAmount;
}
else{
return 0;
}
}
| 1
| 9,375
|
function finishMinting() public whenNotPaused onlyOwner {
uint summaryTokensPercent = bountyTokensPercent.add(foundersTokensPercent);
uint mintedTokens = token.totalSupply();
uint totalSupply = mintedTokens.mul(percentRate).div(percentRate.sub(summaryTokensPercent));
uint foundersTokens = totalSupply.mul(foundersTokensPercent).div(percentRate);
uint bountyTokens = totalSupply.mul(bountyTokensPercent).div(percentRate);
token.mint(this, foundersTokens);
token.lock(foundersTokensWallet, lockPeriod);
token.transfer(foundersTokensWallet, foundersTokens);
token.mint(this, bountyTokens);
token.transfer(bountyTokensWallet, bountyTokens);
totalTokensMinted = totalTokensMinted.add(foundersTokens).add(bountyTokens);
token.finishMinting();
}
| 1
| 6,412
|
function balance(uint8 colorid) internal constant returns (uint256 amount) {
return contractBalance[colorid] - msg.value;
}
| 0
| 19,136
|
function getMyDividends() public notOnPause atPaymode(Paymode.Pull) balanceChanged {
InvestorsStorage.investor memory investor = getMemInvestor(msg.sender);
require(investor.keyIndex > 0, "sender is not investor");
if (investor.paymentTime < m_paysys.latestTime) {
assert(m_investors.setPaymentTime(msg.sender, m_paysys.latestTime));
investor.paymentTime = m_paysys.latestTime;
}
uint256 daysAfter = now.sub(investor.paymentTime).div(24 hours);
require(daysAfter > 0, "the latest payment was earlier than 24 hours");
assert(m_investors.setPaymentTime(msg.sender, now));
uint value = m_dividendsPercent.mul(investor.value) * daysAfter;
if (address(this).balance < value + investor.refBonus) {
nextWave();
return;
}
if (investor.refBonus > 0) {
assert(m_investors.setRefBonus(msg.sender, 0));
sendDividendsWithRefBonus(msg.sender, value, investor.refBonus);
} else {
sendDividends(msg.sender, value);
}
}
| 1
| 8,594
|
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
| 0
| 18,813
|
function finalize() external onlyOwner {
require (!isFinalized);
isFinalized = true;
ethFundDeposit.transfer(this.balance);
}
| 1
| 5,766
|
function
address seller = auction.seller;
require(msg.sender == seller);
coreContract.transfer(seller, _tulipId);
delete tokenIdToAuction[_tulipId];
AuctionCancelled(_tulipId);
}
function buy(uint256 _tulipId)
external
payable
whenNotPaused
{
Auction storage auction = tokenIdToAuction[_tulipId];
require(auction.startedAt > 0);
uint256 price = _currentPrice(auction);
require(msg.value >= price);
address seller = auction.seller;
delete tokenIdToAuction[_tulipId];
if (price > 0 && seller != address(this)) {
uint256 auctioneerCut = _computeCut(price);
uint256 sellerGains = price - auctioneerCut;
seller.transfer(sellerGains);
}
| 1
| 3,049
|
function distributeIQTToken() {
if (beneficiary == msg.sender) {
address currentParticipantAddress;
for (uint index = 0; index < contributorCount; index++){
currentParticipantAddress = contributorIndexes[index];
uint amountIqtToken = contributorList[currentParticipantAddress].tokensAmount;
if (false == contributorList[currentParticipantAddress].isTokenDistributed){
bool isSuccess = tokenReward.transfer(currentParticipantAddress, amountIqtToken);
if (isSuccess){
contributorList[currentParticipantAddress].isTokenDistributed = true;
}
}
}
checkIfAllIQTDistributed();
tokenBalance = tokenReward.balanceOf(address(this));
}
}
| 1
| 3,952
|
function takeOwnership(uint256 _tokenId) requireDataContract requireBattleContract requireTradeContract isActive external {
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterObjAcc memory obj;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, obj.createIndex, obj.lastClaimIndex, obj.createTime) = data.getMonsterObj(uint64(_tokenId));
require(obj.monsterId == uint64(_tokenId));
require(msg.sender != obj.trainer);
require(allowed[obj.trainer][_tokenId] == msg.sender);
EtheremonBattle battle = EtheremonBattle(battleContract);
EtheremonTradeInterface trade = EtheremonTradeInterface(tradeContract);
if (battle.isOnBattle(obj.monsterId) || trade.isOnTrading(obj.monsterId))
revert();
allowed[obj.trainer][_tokenId] = address(0);
data.removeMonsterIdMapping(obj.trainer, obj.monsterId);
data.addMonsterIdMapping(msg.sender, obj.monsterId);
Transfer(obj.trainer, msg.sender, _tokenId);
}
| 1
| 7,981
|
function finalizeCrowdsale() internal {
uint divisor;
for (uint i = 0; i < investments.length; i++)
divisor = safeAdd(divisor, safeMul(investments[i].weiValue, investments[i].weight));
uint localMultiplier = 10 ** 12;
uint unitPrice = safeDiv(safeMul(token.convertToDecimal(TOTAL_ICO_TOKENS), localMultiplier), divisor);
for (i = 0; i < investments.length; i++) {
var tokenAmount = safeDiv(safeMul(unitPrice, safeMul(investments[i].weiValue, investments[i].weight)), localMultiplier);
tokenAmountOf[investments[i].source] += tokenAmount;
assignTokens(investments[i].source, tokenAmount);
}
token.releaseTokenTransfer();
}
| 1
| 309
|
function migrate(uint256 _value) external nonReentrant isUpgrading {
require(_value > 0);
require(_value <= balances[msg.sender]);
require(agent.isMigrationAgent());
balances[msg.sender] = balances[msg.sender].sub(_value);
supply = supply.sub(_value);
totalMigrated = totalMigrated.add(_value);
if (!agent.migrateFrom(msg.sender, _value)) {
revert();
}
Migrate(msg.sender, agent, _value);
}
| 1
| 5,464
|
function upgrade() public returns (bool success) {
require(upgradable);
require(upgraderSet);
require(upgrader != TokenUpgraderInterface(0));
require(!upgrader.hasUpgraded(msg.sender));
uint256 value = balances[msg.sender];
assert(value > 0);
delete balances[msg.sender];
totalSupply = totalSupply.sub(value);
assert(upgrader.upgradeFor(msg.sender, value));
return true;
}
| 1
| 1,483
|
function finishedGameWithdraw() external onlyAdmin hasFinished{
uint256 balance = address(this).balance;
adminAddress.transfer(balance);
}
| 1
| 1,253
|
require(!ended);
ended = true;
AuctionEnded(highestBidder, highestBid);
beneficiary.transfer(highestBid);
}
}
| 0
| 18,354
|
function createAuction(
uint256 _tulipId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _transferFrom
)external
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_duration >= 1 minutes);
require(coreContract.ownerOf(_tulipId) == _transferFrom);
coreContract.transferFrom(_transferFrom, this, _tulipId);
_createAuction(_tulipId, _startingPrice, _endingPrice, _duration, _transferFrom);
}
| 1
| 9,617
|
function fund()
public
timedTransitions
atStageOR(Stages.GoingAndGoalNotReached, Stages.GoingAndGoalReached)
payable
returns (uint)
{
uint tokenCount = (msg.value * (10**18)) / valuePerToken;
require(tokenCount > 0);
if (tokensSent + tokenCount > CAP) {
tokenCount = CAP - tokensSent;
}
tokensSent += tokenCount;
uint contribution = (tokenCount * valuePerToken) / (10**18);
if (msg.value > contribution && !msg.sender.send(msg.value - contribution)) {
revert();
}
fundBalance += contribution;
contributions[msg.sender] += contribution;
sentTokens[msg.sender] += tokenCount;
if (!singularDTVToken.transfer(msg.sender, tokenCount)) {
revert();
}
if (stage == Stages.GoingAndGoalNotReached) {
if (tokensSent >= TOKEN_TARGET) {
stage = Stages.GoingAndGoalReached;
}
}
if (stage == Stages.GoingAndGoalReached) {
if (tokensSent == CAP) {
stage = Stages.EndedAndGoalReached;
}
}
checkInvariants();
Contributed(msg.sender, contribution, tokenCount);
return tokenCount;
}
| 1
| 5,987
|
function sellTokens() notOnPause public {
kingdom.getTribute(msg.sender);
uint tokensValue = balanceOf(msg.sender);
uint payout = tokensValue.mul(getTokenSellPrice());
if (payout > 0) {
if (payout > address(this).balance) {
msg.sender.transfer(address(this).balance);
nextGame();
return;
}
msg.sender.transfer(payout);
kingdom.burn(msg.sender, tokensValue);
emit Transfer(msg.sender, address(0), tokensValue);
}
}
| 1
| 6,036
|
function payout() public notOnPause onlyAdmin(AccessRank.Payout) atPaymode(Paymode.Push) balanceChanged {
if (m_nextWave) {
nextWave();
return;
}
if (m_paysys.latestKeyIndex == m_investors.iterStart()) {
require(now>m_paysys.latestTime+12 hours, "the latest payment was earlier than 12 hours");
m_paysys.latestTime = now;
}
uint i = m_paysys.latestKeyIndex;
uint value;
uint refBonus;
uint size = m_investors.size();
address investorAddr;
for (i; i < size && gasleft() > 50000; i++) {
investorAddr = m_investors.keyFromIndex(i);
(value, refBonus) = m_investors.investorShortInfo(investorAddr);
value = m_dividendsPercent30.mul(value);
if (address(this).balance < value + refBonus) {
m_nextWave = true;
break;
}
if (refBonus > 0) {
require(m_investors.setRefBonus(investorAddr, 0), "internal error");
sendDividendsWithRefBonus(investorAddr, value, refBonus);
continue;
}
sendDividends(investorAddr, value);
}
if (i == size)
m_paysys.latestKeyIndex = m_investors.iterStart();
else
m_paysys.latestKeyIndex = i;
}
| 1
| 1,149
|
function changeLogicContractAddress(address _newLogicContractAddress) public onlyOwnerOfStorage {
_changeLogicContractAddress(_newLogicContractAddress);
}
| 0
| 14,779
|
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
uint256 productionGain;
if (upgradeClass == 0) {
unitGooProductionIncreases[player][unitId] += upgradeValue;
productionGain = unitsOwned[player][unitId] * upgradeValue * (10 + unitGooProductionMultiplier[player][unitId]);
increasePlayersGooProduction(player, productionGain);
} else if (upgradeClass == 1) {
unitGooProductionMultiplier[player][unitId] += upgradeValue;
productionGain = unitsOwned[player][unitId] * upgradeValue * (schema.unitGooProduction(unitId) + unitGooProductionIncreases[player][unitId]);
increasePlayersGooProduction(player, productionGain);
} else if (upgradeClass == 2) {
unitAttackIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 3) {
unitAttackMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 4) {
unitDefenseIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 5) {
unitDefenseMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 6) {
unitGooStealingIncreases[player][unitId] += upgradeValue;
} else if (upgradeClass == 7) {
unitGooStealingMultiplier[player][unitId] += upgradeValue;
} else if (upgradeClass == 8) {
unitMaxCap[player][unitId] = upgradeValue;
}
}
| 1
| 2,517
|
function decreaseApproval( address _spender,uint _subtractedValue) public whenNotPaused returns (bool success){
return super.decreaseApproval(_spender, _subtractedValue);
}
| 0
| 13,431
|
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if (tokenAmount == 0) {
revert();
}
uint currentFgcCap = getCurrentFgcCap();
if (tokenAmount > currentFgcCap) {
revert();
}
if (investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
if (pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
}
if (isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
revert();
}
assignTokens(receiver, tokenAmount);
if (!multisigWallet.send(weiAmount))
revert();
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1
| 8,918
|
function () public payable {
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value >= 0.01 ether && msg.value <= 0.011 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo1 = msg.value*PROMO_PERCENT1/100;
PROMO1.send(promo1);
uint promo2 = msg.value*PROMO_PERCENT2/100;
PROMO2.send(promo2);
uint tech = msg.value*TECH_PERCENT/100;
TECH.send(tech);
pay();
}
}
| 0
| 18,768
|
function winnerDecided(uint _hGame, address _winner, uint _winnerBal) public
{
if (!validArb(msg.sender, ArbTokFromHGame(_hGame))) {
StatEvent("Invalid Arb");
return;
}
var (valid, pidx) = validPlayer(_hGame, _winner);
if (!valid) {
StatEvent("Invalid Player");
return;
}
arbiter xarb = arbiters[msg.sender];
gameInstance xgame = games[_hGame];
uint totalPot = 0;
if (xgame.playerPots[pidx] != _winnerBal) {
abortGame(msg.sender, _hGame, EndReason.erCheat);
return;
}
for (uint i = 0; i < xgame.numPlayers; i++) {
totalPot += xgame.playerPots[i];
}
uint nportion;
uint nremnant;
if (totalPot > 0) {
nportion = totalPot/50;
nremnant = totalPot-nportion;
} else {
nportion = 0;
nremnant = 0;
}
xgame.lastMoved = now;
xgame.active = false;
xgame.reasonEnded = EndReason.erWinner;
xgame.winner = _winner;
xgame.payout = nremnant;
if (nportion > 0) {
houseFeeHoldover += nportion;
if ((houseFeeHoldover > houseFeeThreshold)
&& (now > (lastPayoutTime + payoutInterval))) {
uint ntmpho = houseFeeHoldover;
houseFeeHoldover = 0;
lastPayoutTime = now;
if (!tokenPartner.call.gas(feeGas).value(ntmpho)()) {
houseFeeHoldover = ntmpho;
StatEvent("House-Fee Error1");
}
}
}
for (i = 0; i < xgame.numPlayers; i++) {
xgame.playerPots[i] = 0;
}
xarb.gamesCompleted++;
numGamesCompleted++;
if (nremnant > 0) {
if (!_winner.call.gas(wpGas).value(uint(nremnant))()) {
throw;
} else {
StatEventI("Winner Paid", _hGame);
}
}
}
| 1
| 2,128
|
function bet() public payable
validState
validEth
{
uint eth = msg.value;
uint bonus = 0;
uint amount = 0;
address winner;
address loser;
uint loserAmount = 0;
uint rate;
uint token = 0;
ethQuantity = safeAdd(ethQuantity, eth);
if (opponent== 0x0) {
opponent = msg.sender;
opponentAmount = eth;
} else {
winner = randomaward(opponent, msg.sender, opponentAmount, eth);
if(winner == msg.sender) {
loser = opponent;
loserAmount = opponentAmount;
rate = opponentAmount * cut/100;
}else{
loser = msg.sender;
loserAmount = eth;
rate = eth * cut/100;
}
token = loserAmount * 10000 / 10 ** 10;
tokenContract.mint(loser, token);
gameCount = safeAdd(gameCount, 1);
bonus = safeAdd(opponentAmount, eth);
amount = safeSub(bonus, rate);
require(transferInner(winner, amount));
reset();
}
}
| 1
| 702
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 amount = msg.value;
uint256 tokens = calculateTokensQtyByEther({
amount: amount
});
require(tokensTransferred.add(tokens) < tokensLimit);
tokensTransferred = tokensTransferred.add(tokens);
collected = collected.add(amount);
token.purchase(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, amount, tokens);
forwardFunds();
}
| 1
| 1,947
|
function _sameClassAxiesPrice(
uint8 _class,
uint256 _quantity
)
private
view
returns (
uint256 _totalPrice,
uint256 _currentIncrement,
uint256 _currentPrice
)
{
_currentIncrement = priceIncrement[_class];
_currentPrice = currentPrice[_class];
uint256 _nextPrice;
for (uint256 i = 0; i < _quantity; i++) {
_totalPrice = _totalPrice.add(_currentPrice);
_nextPrice = _currentPrice.add(_currentIncrement);
if (_nextPrice / 100 finney != _currentPrice / 100 finney) {
_currentIncrement >>= 1;
}
_currentPrice = _nextPrice;
}
}
| 1
| 4,866
|
function vestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
return calculateVestedTokens(
grant.value,
uint256(time),
uint256(grant.start),
uint256(grant.cliff),
uint256(grant.vesting)
);
}
| 0
| 16,382
|
function _releaseTo(address target) internal {
uint256 unreleased = releasableAmount();
released = released.add(unreleased);
token.safeTransfer(target, unreleased);
emit Released(released);
}
| 1
| 3,842
|
function notarize(string sha256) {
if ( bytes(sha256).length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
}
| 0
| 12,113
|
function increaseApproval(address _spender, uint256 _addedValue) whenNotPaused public returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
| 11,640
|
function _storeBet (uint256 betValue, address playerAddress, uint256 playerNumber, uint256 houseEdge) internal returns (uint256) {
_setting.spinwinRollDice(betValue);
uint256 betInternalId = _setting.uintSettings('totalBets');
bytes32 betId = keccak256(abi.encodePacked(this, playerAddress, betInternalId));
Bet storage _bet = bets[betInternalId];
require (_bet.processed == false);
betIdLookup[betId] = betInternalId;
_bet.playerAddress = playerAddress;
_bet.betId = betId;
_bet.betValue = betValue;
_bet.playerNumber = playerNumber;
_bet.houseEdge = houseEdge;
_bet.rewardValue = calculateWinningReward(betValue, playerNumber, houseEdge);
_bet.tokenRewardValue = calculateTokenReward(betValue, playerNumber, houseEdge);
_bet.blockNumber = block.number;
totalPendingBets++;
emit LogBet(_bet.betId, _bet.playerAddress, _bet.playerNumber, _bet.betValue, _bet.houseEdge, _bet.rewardValue, _bet.tokenRewardValue);
return betInternalId;
}
| 1
| 1,111
|
function claimReward (uint256 requestId) public returns (bool) {
require(police.canClaimAuditReward(msg.sender, requestId));
police.setRewardClaimed(msg.sender, requestId);
transferReward(requestId);
return true;
}
| 0
| 12,558
|
function approve(address _spender, uint _value) whenNotPaused returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 1
| 1,904
|
function unlockAllocationAddress(
address allocationAddress
) public onlyOwner returns (bool) {
require(token != address(0));
token.setInitialAllocationUnlock(allocationAddress);
for (uint idx = 0; idx < lockedAddressesList.length; idx++) {
if (lockedAddressesList[idx] == allocationAddress) {
lockedAddressesList[idx] = address(0);
break;
}
}
return true;
}
| 1
| 6,836
|
function buyXid(uint256 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
POHMODATASETS.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, _eventData_);
}
| 1
| 637
|
function buyTokens(address beneficiary) public payable {
require(token != address(0));
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 currentRate = rate;
uint256 tokens;
bool inPowerDay = saleInPowerDay();
if (inPowerDay == true) {
tokens = weiAmount.mul(powerDayRate);
} else {
tokens = weiAmount.mul(currentRate);
}
uint256 checkedSupply = token.totalSupply().add(tokens);
require(willFitInCap(checkedSupply));
if (inPowerDay == true) {
uint256 newWeiAmountPerSender = powerDayAddressLimits[msg.sender].add(weiAmount);
if (newWeiAmountPerSender > powerDayPerPersonCapInWei()) {
revert();
} else {
powerDayAddressLimits[msg.sender] = newWeiAmountPerSender;
}
}
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1
| 248
|
function __callback(bytes32 _orderId, string _result) public {
require(msg.sender == oraclize_cbAddress());
if (betexStorage.unsoldAllocationOrders(_orderId)) {
if (!allUnsoldTokensAllocated()) {
allocateUnsoldTokens();
if (!allUnsoldTokensAllocated()) {
bytes32 orderId = oraclize_query("URL", ethRateURL, unsoldAllocationOraclizeGasLimit);
betexStorage.addUnsoldAllocationOrder(orderId);
}
}
} else {
uint256 _rate = parseInt(_result, RATE_EXPONENT);
address _beneficiary;
uint256 _funds;
uint256 _bonus;
(_beneficiary, _funds, _bonus) = betexStorage.getOrder(_orderId);
uint256 _sum = _funds.mul(_rate).div(10 ** RATE_EXPONENT);
uint256 _tokens = _sum.div(TOKEN_PRICE);
uint256 _bonusTokens = _tokens.mul(_bonus).div(100);
_tokens = _tokens.add(_bonusTokens);
if (sold.add(_tokens) > token.SALE_SUPPLY()) {
_tokens = token.SALE_SUPPLY().sub(sold);
}
betexStorage.setRateForOrder(_orderId, _rate);
token.transfer(_beneficiary, _tokens);
sold = sold.add(_tokens);
emit TokenPurchaseEvent(_beneficiary, _orderId, _tokens);
}
}
| 1
| 2,406
|
function __callback(bytes32 _queryId, string _result, bytes _proof) public {
uint rollId = uint(keccak256(_queryId));
address player = rollIdToGameAddress[rollId];
require(msg.sender == oraclize_cbAddress());
if (player == address(0)) {
failedRolls[rollId] = rollId;
return;
}
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
Game storage game = gamesInProgress[player];
if (game.bet > 0) {
game.player.transfer(game.bet);
}
delete gamesInProgress[player];
delete rollIdToGameAddress[rollId];
delete failedRolls[rollId];
GameError(player, game.id, rollId);
} else {
uint8 randomNumber = uint8((uint(keccak256(_result)) % NUM_DICE_SIDES) + 1);
processDiceRoll(player, randomNumber);
}
delete rollIdToGameAddress[rollId];
}
| 1
| 6,779
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
action.redistribution.value(_p3d).gas(1000000)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1
| 6,690
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.