func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function processPayment(uint moneyValue, bytes refData) private
{
if (msg.sender == owner)
{
totalSelfInvest = totalSelfInvest.add(moneyValue);
emit LogSelfInvestment(moneyValue);
return;
}
if (moneyValue == 0)
{
preparePayment();
return;
}
if (moneyValue < minimalDeposit)
{
totalPenalty = totalPenalty.add(moneyValue);
emit LogMinimalDepositPayment(msg.sender, moneyValue, totalPenalty);
return;
}
address referrer = bytesToAddress(refData);
if (user[msg.sender].balance > 0 ||
refData.length != 20 ||
moneyValue > getCurrentMaximalDeposit() ||
referrer != owner &&
(
user[referrer].balance <= 0 ||
referrer == msg.sender)
)
{
uint amount = moneyValue.mul(procReturn).div(procKoef);
totalPenalty = totalPenalty.add(moneyValue.sub(amount));
emit LogPenaltyPayment(msg.sender, user[msg.sender].balance, refData.length, referrer, user[referrer].balance, moneyValue, amount, totalPenalty);
msg.sender.transfer(amount);
return;
}
uint nDay = getCurrentDay();
uint restDepositPerDay = getDayRestDepositLimit(nDay);
uint addDeposit = moneyValue;
if (moneyValue > restDepositPerDay)
{
uint returnDeposit = moneyValue.sub(restDepositPerDay);
uint returnAmount = returnDeposit.mul(procReturn).div(procKoef);
addDeposit = addDeposit.sub(returnDeposit);
totalPenalty = totalPenalty.add(returnDeposit.sub(returnAmount));
emit LogExceededRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, returnDeposit, returnAmount, totalPenalty, addDeposit);
msg.sender.transfer(returnAmount);
}
usedDeposit[nDay] = usedDeposit[nDay].add(addDeposit);
emit LogUsedRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, addDeposit, usedDeposit[nDay]);
registerInvestor(referrer);
sendOwnerFee(addDeposit);
calcBonusReferrers(referrer, addDeposit);
updateInvestBalance(addDeposit);
} | 1 | 994 |
function purchase(uint _divCardId)
public
payable
hasStarted
isNotContract
{
address oldOwner = divCardIndexToOwner[_divCardId];
address newOwner = msg.sender;
uint currentPrice = divCardIndexToPrice[_divCardId];
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= currentPrice);
uint percentIncrease = divCards[_divCardId].percentIncrease;
uint previousPrice = SafeMath.mul(currentPrice, 100).div(100 + percentIncrease);
uint totalProfit = SafeMath.sub(currentPrice, previousPrice);
uint oldOwnerProfit = SafeMath.div(totalProfit, 2);
uint bankrollProfit = SafeMath.sub(totalProfit, oldOwnerProfit);
oldOwnerProfit = SafeMath.add(oldOwnerProfit, previousPrice);
uint purchaseExcess = SafeMath.sub(msg.value, currentPrice);
divCardIndexToPrice[_divCardId] = SafeMath.div(SafeMath.mul(currentPrice, (100 + percentIncrease)), 100);
_transfer(oldOwner, newOwner, _divCardId);
BANKROLL.send(bankrollProfit);
oldOwner.send(oldOwnerProfit);
msg.sender.transfer(purchaseExcess);
} | 1 | 934 |
function addSellOrder(uint _price, uint _amount) public {
require(is111bit(_price) && is111bit(_amount), "Price or amount exceeds 111 bits");
require(_price > 0, "Price needs to be greater than 0");
require(_amount > 0, "Amount needs to be greater than 0");
uint orderFee = feeForOrder(_price, _amount);
uint index = addressRegister(msg.sender);
if (orderFee > 0) {
require(feeBalances[index] >= orderFee, "You do not have enough deposited for fees");
feeBalances[index] = feeBalances[index].sub(orderFee);
feeBalances[0] = feeBalances[0].add(orderFee);
lockedFees = lockedFees.add(orderFee);
}
poolOwners.sendOwnershipFrom(msg.sender, this, _amount);
require(
!orderBook.insert(orderCount, (((uint(ORDER_TYPE.SELL) << 32 | index) << 111 | _price) << 111) | _amount),
"Map replacement detected"
);
orderCount += 1;
emit NewOrder(ORDER_TYPE.SELL, msg.sender, _price, _amount);
} | 1 | 371 |
function getCompoundingLevel(address _owner) public view returns (uint256) {
uint256 level = compoundedInterestFactor[_owner];
if (level == 0) {
return SCALEFACTOR;
} else {
return level;
}
} | 0 | 2,461 |
function mint(address _to, uint256 _amount)
onlyOwner
canMint
public
returns (bool)
{
revert();
return true;
} | 0 | 2,084 |
function getAffReward() external nonReentrant {
aff.sendAffReward(address(0x0), msg.sender);
} | 1 | 593 |
function withdraw()
isActivated()
senderVerify()
playerVerify()
public
{
address _player = msg.sender;
uint256[] memory _playerGoodsList = playerGoodsList[_player];
uint256 length = _playerGoodsList.length;
uint256 _totalAmount;
uint256 _amount;
uint256 _withdrawSid;
uint256 _reachAmount;
bool _finish;
uint256 i;
delete playerGoodsList[_player];
while(i < length){
(_amount, _withdrawSid, _reachAmount, _finish) = getEarningsAmountByGoodsIndex(_playerGoodsList[i]);
if(_finish == true){
playerWithdrawList[_player].push(_playerGoodsList[i]);
}else{
goodsList[_playerGoodsList[i]].withdrawSid = _withdrawSid;
goodsList[_playerGoodsList[i]].reachAmount = _reachAmount;
playerGoodsList[_player].push(_playerGoodsList[i]);
}
_totalAmount = _totalAmount.add(_amount);
i++;
}
_player.transfer(_totalAmount);
} | 1 | 726 |
function calculateAndTransferTokensWithReferrer(address to, uint investedInWei) internal {
uint tokens = calculateAndTransferTokens(to, investedInWei);
sendReferrerTokens(tokens);
} | 1 | 826 |
function sendBouns() external acceptDividend shareholderOnly {
_sendBonus();
} | 1 | 687 |
function makeOwnerBitmapBit(address owner) private constant returns (uint) {
uint ownerIndex = checkOwnerIndex(m_ownerIndex[owner]);
return 2 ** ownerIndex;
} | 0 | 2,130 |
function __callback(bytes32 _myid, string _result) {
require(msg.sender == oraclize_cbAddress());
address queryAddress = data.getAddressForQuery(_myid);
bytes32 usernameAddress = data.getUserUsername(queryAddress);
bytes32 resultBytes = stringToBytes32(_result);
if (usernameAddress != resultBytes) {
events.usernameDoesNotMatch(resultBytes, usernameAddress);
return;
}
data.setVerified(queryAddress);
data.setUsernameForAddress(usernameAddress, queryAddress);
events.verifiedUser(usernameAddress);
sendTip(usernameAddress, data.getBalanceForUser(usernameAddress));
} | 1 | 136 |
function LocalEthereumEscrows() public {
owner = msg.sender;
arbitrator = msg.sender;
relayer = msg.sender;
requestCancellationMinimumTime = 2 hours;
} | 1 | 628 |
function becomeSponsor() public isNotOver isCurrentRound payable
{
require(msg.value >= getSponsorFee());
sponsor.send(getCurrentPrice(sponsorLevel));
sponsor = msg.sender;
sponsorLevel = SafeMath.add(sponsorLevel, 1);
} | 1 | 334 |
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x45a709aff6d5ae42cb70f87551d8d7dbec5235cf2baa71a009ed0a9795258d8f, 0);
} | 0 | 2,670 |
function () paused public payable {
require(block.timestamp > ClaimingTimeLimit);
Investors[msg.sender] += msg.value;
unClaimedEther += msg.value;
emit eDeposit(msg.sender, msg.value);
} | 0 | 2,223 |
function VillanovavsRadford() public payable {
owner = msg.sender;
callOracle(EXPECTED_END - now, ORACLIZE_GAS);
callOracle(RETURN_DATE - now, ORACLIZE_GAS);
} | 1 | 1,109 |
function proposeAllocation(address _proposerAddress, address _dest, uint256 _tokensPerPeriod) public onlyOwner {
require(_tokensPerPeriod > 0);
require(_tokensPerPeriod <= remainingTokensPerPeriod);
require(allocationOf[_dest].proposerAddress == 0x0 || allocationOf[_dest].allocationState == Types.AllocationState.Rejected);
if (allocationOf[_dest].allocationState != Types.AllocationState.Rejected) {
allocationAddressList.push(_dest);
}
allocationOf[_dest] = Types.StructVestingAllocation({
tokensPerPeriod: _tokensPerPeriod,
allocationState: Types.AllocationState.Proposed,
proposerAddress: _proposerAddress,
claimedPeriods: 0
});
remainingTokensPerPeriod = remainingTokensPerPeriod - _tokensPerPeriod;
} | 0 | 1,601 |
function cancelBid(address _tokenAddress, uint256 _tokenId) public whenNotPaused() {
(uint256 bidIndex, bytes32 bidId,,,) = getBidByBidder(
_tokenAddress,
_tokenId,
msg.sender
);
_cancelBid(
bidIndex,
bidId,
_tokenAddress,
_tokenId,
msg.sender
);
} | 0 | 2,603 |
function deliver(uint64 requestId, bytes32 paramsHash, uint64 error, bytes32 respData) public {
if (msg.sender != SGX_ADDRESS ||
requestId <= 0 ||
requests[requestId].requester == 0 ||
requests[requestId].fee == DELIVERED_FEE_FLAG) {
return;
}
uint fee = requests[requestId].fee;
if (requests[requestId].paramsHash != paramsHash) {
return;
} else if (fee == CANCELLED_FEE_FLAG) {
SGX_ADDRESS.send(CANCELLATION_FEE);
requests[requestId].fee = DELIVERED_FEE_FLAG;
unrespondedCnt--;
return;
}
requests[requestId].fee = DELIVERED_FEE_FLAG;
unrespondedCnt--;
if (error < 2) {
SGX_ADDRESS.send(fee);
} else {
externalCallFlag = true;
requests[requestId].requester.call.gas(2300).value(fee)();
externalCallFlag = false;
}
uint callbackGas = (fee - MIN_FEE) / tx.gasprice;
DeliverInfo(requestId, fee, tx.gasprice, msg.gas, callbackGas, paramsHash, error, respData);
if (callbackGas > msg.gas - 5000) {
callbackGas = msg.gas - 5000;
}
externalCallFlag = true;
requests[requestId].callbackAddr.call.gas(callbackGas)(requests[requestId].callbackFID, requestId, error, respData);
externalCallFlag = false;
} | 1 | 710 |
function calculateAndSendRefund(
address payer,
uint gasUsed,
uint gasPrice,
uint percentMultiplier)
internal
{
if (gasUsed == 0 || gasPrice == 0)
return;
gasUsed = gasUsed - gasleft();
sendRefund(
payer,
gasUsed,
gasPrice,
percentMultiplier
);
} | 1 | 1,039 |
function transferTokenOwnership(address _newOwner) onlyOwner public {
Ownable(token).transferOwnership(_newOwner);
} | 0 | 1,736 |
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
require(newBasisPoints < MAX_SETTABLE_BASIS_POINTS);
require(newMaxFee < MAX_SETTABLE_FEE);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(uint(10)**decimals);
emit Params(basisPointsRate, maximumFee);
} | 0 | 1,706 |
function vestedAmount(address _recipient) public view returns (uint256) {
if( block.timestamp < beneficiaries[_recipient].cliff ) {
return 0;
}else if( block.timestamp >= add( beneficiaries[_recipient].cliff, (30 days)*beneficiaries[_recipient].periods ) ) {
return beneficiaries[_recipient].totalAllocated;
}else {
for(uint i = 0; i < beneficiaries[_recipient].periods; i++) {
if( block.timestamp >= add( beneficiaries[_recipient].cliff, (30 days)*i ) && block.timestamp < add( beneficiaries[_recipient].cliff, (30 days)*(i+1) ) ) {
return div( mul(i, beneficiaries[_recipient].totalAllocated), beneficiaries[_recipient].periods );
}
}
}
} | 0 | 1,910 |
function getName(address _user) external view returns (bytes32) {
return names[_user];
} | 0 | 2,662 |
function _isStraight(uint256 _card) private pure returns(bool _result){
_result = false;
if(_card >= 543210){
if(_isKingKong(_card.sub(12345)) || _isKingKong(_card.sub(543210))){
_result = true ;
}
}else if(_card > 123455){
if(_isKingKong(_card.sub(12345))){
_result = true ;
}
}else{
_result = false;
}
} | 0 | 2,430 |
function KansasvsClemson() public payable {
owner = msg.sender;
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END - now, ORACLIZE_GAS);
} | 1 | 1,112 |
function finalize() {
if (msg.sender != buyer && msg.sender != arbiter) throw;
seller.send(this.balance);
} | 1 | 465 |
function fillBuyOrder(uint _key) public {
uint order = orderBook.get(_key);
ORDER_TYPE orderType = ORDER_TYPE(order >> 254);
require(orderType == ORDER_TYPE.BUY, "This is not a buy order");
uint index = addressRegister(msg.sender);
require(index != (order << 2) >> 224, "You cannot fill your own order");
uint price = (order << 34) >> 145;
uint amount = (order << 145) >> 145;
uint orderFee = feeForOrder(price, amount);
require(feeBalances[index] >= orderFee, "You do not have enough deposited fees to fill this order");
uint cost = price.mul(amount).div(1 ether);
require(orderBook.remove(_key), "Map remove failed");
msg.sender.transfer(cost);
poolOwners.sendOwnershipFrom(msg.sender, addressRegistry[(order << 2) >> 224], amount);
if (orderFee > 0) {
feeBalances[index] = feeBalances[index].sub(orderFee);
uint totalFee = orderFee.mul(2);
totalFees = totalFees.sub(totalFee);
feeToken.transfer(poolOwners, totalFee);
}
emit OrderFilled(orderType, addressRegistry[(order << 2) >> 224], msg.sender, price, amount);
} | 1 | 1,223 |
function deposit(bytes32 _listingHash, uint _amount) external {
Listing storage listing = listings[_listingHash];
require(listing.owner == msg.sender);
listing.unstakedDeposit = listing.unstakedDeposit.add(_amount);
totalStaked[listing.owner] = totalStaked[listing.owner].add(_amount);
require(token.transferFrom(msg.sender, this, _amount));
emit _Deposit(_listingHash, _amount, listing.unstakedDeposit);
} | 0 | 1,801 |
function GetSpud(address MN) public payable
{
require(msg.value >= 1 finney);
address sender = msg.sender;
uint256 blocknr = block.number;
uint256 curround = round;
uint256 refblocknr = Spudgame[curround].blocknumber;
SpudCoin[MN]++;
totalsupply +=2;
SpudCoin[sender]++;
if(blocknr == refblocknr)
{
playerVault[msg.sender] += msg.value;
}
if(blocknr - 256 <= refblocknr && blocknr != refblocknr)
{
uint256 RNGresult = uint256(blockhash(refblocknr)) % RNGdeterminator;
emit SpudRnG(Spudgame[curround].player , RNGresult) ;
Pot += msg.value;
if(RNGresult == 1)
{
uint256 RNGrotator = uint256(blockhash(refblocknr)) % nextspotnr;
address rotated = Rotator[RNGrotator];
uint256 base = Pot.div(10);
p3dContract.buy.value(base)(rotated);
Spudgame[curround].player.transfer(base.mul(5));
emit payout(Spudgame[curround].player , base.mul(5));
Pot = Pot.sub(base.mul(6));
uint256 nextround = curround+1;
Spudgame[nextround].player = sender;
Spudgame[nextround].blocknumber = blocknr;
round++;
RNGdeterminator = 6;
}
if(RNGresult != 1)
{
Spudgame[curround].player = sender;
Spudgame[curround].blocknumber = blocknr;
}
}
if(blocknr - 256 > refblocknr)
{
Pot += msg.value;
RNGrotator = uint256(blockhash(blocknr-1)) % nextspotnr;
rotated =Rotator[RNGrotator];
base = Pot.div(10);
p3dContract.buy.value(base)(rotated);
Spudgame[round].player.transfer(base.mul(5));
emit payout(Spudgame[round].player , base.mul(5));
Pot = Pot.sub(base.mul(6));
nextround = curround+1;
Spudgame[nextround].player = sender;
Spudgame[nextround].blocknumber = blocknr;
round++;
RNGdeterminator = 6;
}
} | 0 | 2,864 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth / 100).mul(3);
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)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 0 | 2,262 |
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= _allowance[msg.sender][_spender]) {
_allowance[msg.sender][_spender] = 0;
} else {
_allowance[msg.sender][_spender] = sub(_allowance[msg.sender][_spender], _value);
}
emit Approval(msg.sender, _spender, _allowance[msg.sender][_spender]);
return true;
} | 0 | 1,508 |
function finalize() public ended() onlyOwner() {
require(finalized == false, "can withdraw only once");
require(initialPrice == false, "can withdraw only if there were bids");
finalized = true;
beneficiary.send(price);
bids[winner] = 0;
for (uint i = 0; i < accountsList.length; i++) {
if (bids[accountsList[i]] > 0) {
accountsList[i].send( bids[accountsList[i]] );
bids[accountsList[i]] = 0;
}
}
} | 1 | 1,104 |
function finishDeal(uint _dealNumber) public{
uint deal = dealNumbers[_dealNumber];
require(deals[deal].balance > 0 && deals[deal].status == statuses.signed );
if(msg.sender == deals[deal].buyer){
signs[deal].finishSignBuyer = msg.sender;
}
if(msg.sender == deals[deal].seller){
signs[deal].finishSignSeller = msg.sender;
}
if(msg.sender ==deals[deal].signer){
signs[deal].finishSignSigner = msg.sender;
}
uint signCount = 0;
if(deals[deal].buyer == signs[deal].finishSignBuyer){
signCount++;
}
if(deals[deal].seller == signs[deal].finishSignSeller){
signCount++;
}
if(deals[deal].signer == signs[deal].finishSignSigner){
signCount++;
}
if(signCount >= 2){
deals[deal].seller.transfer(deals[deal].sum - deals[deal].fee);
emit MoneyTransfer(this,deals[deal].seller,deals[deal].sum-deals[deal].fee);
agencyReceiver.transfer(deals[deal].fee);
emit MoneyTransfer(this,agencyReceiver,deals[deal].fee);
deals[deal].balance = 0;
deals[deal].status = statuses.finished;
deals[deal].atClosed = now;
}
} | 0 | 1,833 |
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns(uint256)
{
Ninja storage matron = ninjas[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Ninja storage sire = ninjas[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = ninjaIndexToOwner[_matronId];
uint256 ninjaId = _createNinja(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
delete matron.siringWithId;
pregnantNinjas--;
msg.sender.send(autoBirthFee);
return ninjaId;
} | 1 | 338 |
function calculateEthersAmount(uint256 _tokens) public view returns (uint256 ethers, uint256 usdAmount) {
if (_tokens == 0) {
return (0, 0);
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
if (endTime < block.timestamp) {
return (0, 0);
}
if (startTime > block.timestamp) {
activeTier = PRE_ICO_TIER_FIRST;
}
}
usdAmount = _tokens.mul((price * (100 - tiers[activeTier].discount) / 100));
ethers = usdAmount.div(etherPriceInUSD);
if (ethers < getMinEthersInvestment()) {
return (0, 0);
}
usdAmount = usdAmount.div(uint256(10) ** 18);
} | 0 | 1,918 |
function getContractAddress() public constant returns(address) {
return this;
} | 0 | 2,573 |
function ExtraBalToken() {
owner = msg.sender;
} | 0 | 2,425 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
uint lock = 0;
for (uint k = 0; k < ActiveProposals.length; k++) {
if (ActiveProposals[k].endTime > now) {
if (lock < voted[ActiveProposals[k].propID][_from]) {
lock = voted[ActiveProposals[k].propID][_from];
}
}
}
require(safeSub(balances[_from], lock) >= _value);
require(allowed[_from][msg.sender] >= _value);
if (ownersIndex[_to] == false && _value > 0) {
ownersIndex[_to] = true;
owners.push(_to);
}
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
ChangeOverPeriod[_from][N] = ChangeOverPeriod[_from][N] - int256(_value);
ChangeOverPeriod[_to][N] = ChangeOverPeriod[_to][N] + int256(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 | 2,708 |
function transferFrom(address _from, address _to, uint _value) public
validTransaction(_from, _to, _value)
returns (bool _success)
{
if(isAdmin()==true) {
emit TransferTokenFromByAdmin(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFromByAdmin(_from,_to, _value);
}
else {
emit TransferTokenFrom(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFrom(_from, _to, _value);
}
if(_success==false) revert();
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push( history_token_transfer_obj( {
_from: _from,
_to: _to,
_token_value: _value,
_when: block.timestamp
} ) );
} | 0 | 1,948 |
function canSubAllocation(address sender, uint256 sub_value) private constant returns(bool) {
if (sub_value == 0) {
return false;
}
if (balances[sender] < sub_value) {
return false;
}
uint256 alllock_sum = 0;
for (uint j = 0; j < allocations[sender].length; j++) {
if (allocations[sender][j].time >= block.timestamp) {
alllock_sum = alllock_sum.add(allocations[sender][j].balance);
}
}
uint256 can_unlock = balances[sender].sub(alllock_sum);
return can_unlock >= sub_value;
} | 0 | 1,551 |
function chargeOwe(bytes32 secretKey_D_hash) public {
require(!TicketPool[secretKey_D_hash].isPay);
require(TicketPool[secretKey_D_hash].isPlay);
require(TicketPool[secretKey_D_hash].Result != 0);
if(address(this).balance >= TicketPool[secretKey_D_hash].Result){
if (TicketPool[secretKey_D_hash].Buyer.send(TicketPool[secretKey_D_hash].Result)) {
TicketPool[secretKey_D_hash].isPay = true;
OwePay(secretKey_D_hash, TicketPool[secretKey_D_hash].Buyer, TicketPool[secretKey_D_hash].Result);
}
}
} | 0 | 2,799 |
function registered(string _playerName)
senderVerify()
registerVerify()
payable
public
{
bytes32 _name = _playerName.nameFilter();
require(_name != bytes32(0), "name cannot be empty");
require(playerName[_name] == address(0), "this name has already been registered");
require(register[msg.sender] == bytes32(0), "please do not repeat registration");
playerName[_name] = msg.sender;
register[msg.sender] = _name;
developerAddr.send(msg.value);
} | 1 | 816 |
function deposit(address referrerAddr) public payable {
uint depositAmount = msg.value;
address investorAddr = msg.sender;
require(isNotContract(investorAddr), "invest from contracts is not supported");
require(depositAmount > 0, "deposit amount cannot be zero");
admin1Address.send(depositAmount * 70 / 1000);
admin2Address.send(depositAmount * 15 / 1000);
admin3Address.send(depositAmount * 15 / 1000);
Investor storage investor = investors[investorAddr];
bool senderIsNotPaticipant = !investor.isParticipant;
bool referrerIsParticipant = investors[referrerAddr].isParticipant;
if (senderIsNotPaticipant && referrerIsParticipant && referrerAddr != investorAddr) {
uint referrerBonus = depositAmount * 3 / 100;
uint referralBonus = depositAmount * 1 / 100;
referrerAddr.transfer(referrerBonus);
investorAddr.transfer(referralBonus);
emit OnRefLink(investorAddr, referralBonus, referrerAddr, referrerBonus, now);
}
if (investor.deposit == 0) {
investorsNumber++;
investor.isParticipant = true;
emit OnNewInvestor(investorAddr, now);
}
investor.deposit += depositAmount;
investor.paymentTime = now;
investmentsNumber++;
emit OnInvesment(investorAddr, depositAmount, now);
} | 1 | 1,067 |
function send(address _to, uint256 _amount, bytes _userData) public canTrade {
super.send(_to, _amount, _userData);
} | 1 | 274 |
function checkUnique(uint256 _genome) public view returns (bool) {
uint256 _flowerId = uint256(genomeFlowerIds[_genome]);
return !(_flowerId > 0);
} | 0 | 2,159 |
function safeWithdrawal(address _receiver, uint256 _value) public {
require((msg.sender == _owner));
uint256 valueAsEth = mul(_value,1 ether);
require(valueAsEth < this.balance);
_receiver.send(valueAsEth);
} | 1 | 865 |
function SwitzerlandvsCostaRica() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 101 |
function setTimeLockAddress(TimeLock _timeLockContract) public onlyOwner returns (bool) {
require(_timeLockContract.getERC20() == address(this));
timeLockContract = _timeLockContract;
emit SetTimeLockAddress(_timeLockContract);
return true;
} | 0 | 1,501 |
function char(byte b) returns (byte c) {
if (b < 10) return byte(uint8(b) + 0x30);
else return byte(uint8(b) + 0x57);
} | 0 | 2,855 |
function hasValue(
Values[] storage values
)
internal
constant
returns (bool)
{
return values.length > 0;
} | 0 | 2,043 |
function pushDividends(address investor) payable public onlyThenCompletedICO {
sendDividends(investor, transferGASUsage.mul(tx.gasprice));
} | 1 | 107 |
function calculate_price(uint256 _pre_pay_in_price,uint256 _post_pay_in_price) private pure returns(uint256) {
return (_pre_pay_in_price.add(_post_pay_in_price)).div(2);
} | 0 | 1,717 |
function withdrawBalancesToLogic() external onlyCLevel {
saleAuction.withdrawBalanceFromStorageContract();
siringAuction.withdrawBalanceFromStorageContract();
activityCore.withdrawBalanceFromStorageContract();
} | 0 | 1,521 |
function migrateDungeon(uint _difficulty, uint _capacity, uint _floorNumber, uint _rewards, uint _seedGenes, uint _floorGenes, address _owner) external {
require(now < 1520694000 && tx.origin == 0x47169f78750Be1e6ec2DEb2974458ac4F8751714);
_createDungeon(_difficulty, _capacity, _floorNumber, _rewards, _seedGenes, _floorGenes, _owner);
} | 0 | 2,884 |
function revealSeckey(bytes32 _secKey) onlyOwner public {
require(block.timestamp > endTime);
ballotEncryptionSeckey = _secKey;
seckeyRevealed = true;
SeckeyRevealed(_secKey);
} | 0 | 2,661 |
function assertIsWhitelisted(address _target) public view returns (bool) {
require(whitelist[_target]);
return true;
} | 0 | 1,803 |
function ***DO NOT OVERRIDE***
*/
function () external payable {
buyTokens(msg.sender);
} | 0 | 1,624 |
function payForMyself(uint128 customerId) public payable {
pay(customerId, msg.sender);
} | 0 | 2,064 |
function is called after March 31., 2019
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 | 2,510 |
function Anaco() {
balances[msg.sender] = 15000000000000000000000000000;
totalSupply = 15000000000000000000000000000;
name = "Anaco";
decimals = 18;
symbol = "ANAC";
unitsOneEthCanBuy = 166666666;
fundsWallet = msg.sender;
} | 0 | 2,254 |
function buyTokens(uint16 _bidPrice) {
if (tx.origin != msg.sender) {
if (!msg.sender.send(msg.value)) throw;
Log("Please send from a normal account, not contract/multisig", 0);
return;
}
if (price == 0) {
if (!tx.origin.send(msg.value)) throw;
Log("Contract disabled", 0);
return;
}
if (_bidPrice < price) {
if (!tx.origin.send(msg.value)) throw;
Log("Bid too low, price is:", price);
return;
}
if (msg.value == 0) {
Log("No ether received", 0);
return;
}
uint _tokenSupply = tokenSupply();
if (_tokenSupply == 0) {
if (!tx.origin.send(msg.value)) throw;
Log("No tokens available, please try later", 0);
return;
}
uint _tokensToPurchase = (msg.value * 1000) / price;
if (_tokensToPurchase <= _tokenSupply) {
if (!tokenContract.transferFrom(tokenHolder, tx.origin, _tokensToPurchase))
throw;
tokensPurchasedTotal += _tokensToPurchase;
ethCostTotal += msg.value;
TokensPurchased(tx.origin, price, _tokensToPurchase, msg.value, msg.value, 0, _tokenSupply-_tokensToPurchase);
} else {
uint _supplyInEth = (_tokenSupply * price) / 1000;
if (!tx.origin.send(msg.value-_supplyInEth))
throw;
if (!tokenContract.transferFrom(tokenHolder, tx.origin, _tokenSupply))
throw;
tokensPurchasedTotal += _tokenSupply;
ethCostTotal += _supplyInEth;
TokensPurchased(tx.origin, price, _tokenSupply, _supplyInEth, msg.value, msg.value-_supplyInEth, 0);
}
} | 0 | 2,732 |
function _buy(address _token, uint _tokenId, Currency _currency, uint _price, address _buyer) internal {
bytes32 key = _getHashKey(_token, _tokenId);
Currency currency = listings[key].currency;
address seller = listings[key].seller;
address currencyAddress = _currency == Currency.PLAT ? address(PLAT) : address(0);
require(currency == _currency, "Wrong currency.");
require(_price > 0 && _price == listings[key].price, "Invalid price.");
require(listings[key].expiry > now, "Item expired.");
ERC721 gameToken = ERC721(_token);
require(gameToken.ownerOf(_tokenId) == address(this), "Item is not available.");
if (_currency == Currency.PLAT) {
require(PLAT.transferFrom(_buyer, address(this), _price), "PLAT payment transfer failed.");
}
gameToken.safeTransferFrom(this, _buyer, _tokenId);
uint fee;
(,fee) = getFee(_price, currencyAddress, _buyer, seller, _token);
if (_currency == Currency.PLAT) {
PLAT.transfer(seller, _price - fee);
} else {
require(seller.send(_price - fee) == true, "Transfer to seller failed.");
}
emit LogItemSold(_buyer, seller, _token, _tokenId, _price, currency, now);
delete(listings[key]);
} | 0 | 2,736 |
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_dividendsPercent.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 | 712 |
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.send(m_advertisingPercent.mul(receivedEther));
adminsAddress.send(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 referrerBonus = m_referrer_percent.mmul(investment);
if (investment > 10 ether) {
referrerBonus = m_referrer_percentMax.mmul(investment);
}
uint referalBonus = m_referal_percent.mmul(investment);
assert(m_investors.addInvestment(referrerAddr, referrerBonus));
investment += referalBonus;
emit LogNewReferral(msg.sender, referrerAddr, now, referalBonus);
}
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 | 72 |
function seedMegball()
internal
{
if (outboundToMegaball > 100000000000000000) {
uint256 value = outboundToMegaball;
outboundToMegaball = 0;
megaballContract.seedJackpot.value(value)();
}
} | 0 | 1,800 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 10;
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 {
_com.add(_aff);
}
com.transfer(_com);
return(_eventData_);
} | 0 | 2,184 |
function setup(address _bouncyCoinToken, uint256 _maxPreIcoDuration, uint256 _maxIcoDuration)
public
isOwner
atStage(Stages.Deployed) {
require(_bouncyCoinToken != 0x0);
require(_maxPreIcoDuration > 0);
require(_maxIcoDuration > 0);
icoPriceThresholds[0] = PriceThreshold(20000000 * 10**18, 0.00020 * 10**18, 0);
icoPriceThresholds[1] = PriceThreshold(50000000 * 10**18, 0.00025 * 10**18, 0);
bouncyCoinToken = ERC20(_bouncyCoinToken);
maxPreIcoDuration = _maxPreIcoDuration;
maxIcoDuration = _maxIcoDuration;
uint256 tokensRequired = PRE_ICO_TOKENS + maxIcoTokensSold();
assert(bouncyCoinToken.balanceOf(this) == tokensRequired);
stage = Stages.SetUp;
} | 0 | 2,468 |
function generatePresaleHouse() onlyByOwnerOrDev onlyDuringPresale public {
uint houseId = generateHouse(this);
uint sellPrice = (houses[houseId].propertyValue / 5000) * 1 finney;
if (sellPrice > 250 finney) sellPrice = 250 finney;
if (sellPrice < 50 finney) sellPrice = 50 finney;
createListing(houseId, sellPrice, 0, 30);
} | 0 | 2,785 |
function (bool wasTransactions) external callback = validIds[queryId];
delete validIds[queryId];
callback(bytes(result).length != 0);
}
function buildUrl(address target, uint startBlock, uint endBlock) internal constant returns (string) {
strings.slice memory strAddress = toHex(target).toSlice();
uint8 i = 0;
var parts = new strings.slice[](9);
parts[i++] = "json(https:
parts[i++] = strAddress;
parts[i++] = "&startblock=".toSlice();
parts[i++] = uint2str(startBlock).toSlice();
parts[i++] = "&endblock=".toSlice();
parts[i++] = uint2str(endBlock).toSlice();
parts[i++] = "&sort=desc&apikey=FJ39P2DIU8IX8U9N2735SUKQWG3HPPGPX8).result[?(@.from=='0x".toSlice();
parts[i++] = strAddress;
parts[i++] = "')].timeStamp".toSlice();
return "".toSlice()
.join(parts);
}
function parseJsonArrayAndGetFirstElementAsNumber(string json) internal constant returns (uint) {
var jsonSlice = json.toSlice();
strings.slice memory firstResult;
jsonSlice.split(", ".toSlice(), firstResult);
var ts = firstResult.beyond("[\"".toSlice()).toString();
return parseInt(ts);
}
function toHex(address adr) internal constant returns (string) {
var ss = new bytes(40);
for (uint i = 0; i < 40; i ++) {
uint c;
assembly {
c := and(adr, 0xf)
adr := div(adr, 0x10)
c := add(add(c, 0x30), mul(0x27, gt(c, 9)))
}
ss[39-i] = byte(c);
} | 1 | 481 |
function withdrawAll ()
returns (bool _success) {
if (msg.sender != client) throw;
updateCapital ();
if (capital > 0) {
if (client.send (capital)) {
Withdrawal (capital);
capital = 0;
return true;
} else return false;
} else return true;
} | 0 | 2,133 |
function _unfreezeMaxTokens(uint _value) internal {
uint amount = frozenBalanceOf[msg.sender] > _value ? _value : frozenBalanceOf[msg.sender];
if (amount > 0) {
balanceOf[msg.sender] += amount;
frozenBalanceOf[msg.sender] -= amount;
Transfer(this, msg.sender, amount);
}
} | 0 | 1,530 |
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
uint amount = value/104;
msg.sender.transfer(amount);
Party(msg.sender, amount);
partyTime = partyTime + 604800;
} | 0 | 1,879 |
function recycle(address farmer) internal {
var elapsed = block.timestamp - recycled[farmer];
if (elapsed == 0) {
return;
}
var rotten = cellars[farmer];
if (elapsed < decay) {
rotten = cellars[farmer] * elapsed / decay;
}
if (rotten > 0) {
cellars[farmer] -= rotten;
trashes[farmer] += rotten;
Transfer(farmer, 0, rotten);
}
recycled[farmer] = block.timestamp;
} | 0 | 1,514 |
function roundClaimICOKeys(uint256 _rID)
private
{
round_[_rID].eth = round_[_rID].ico;
round_[_rID].keys = (round_[_rID].ico).keys();
round_[_rID].icoAvg = calcAverageICOPhaseKeyPrice(_rID);
uint256 _ppt = ((round_[_rID].icoGen).mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = (round_[_rID].icoGen).sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000));
if (_dust > 0)
round_[_rID].pot = (_dust).add(round_[_rID].pot);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
} | 0 | 2,858 |
function rejectAllocation(address _address) public onlyOwner {
var tmp = allocationOf[_address];
require(tmp.allocationState == Types.AllocationState.Proposed);
allocationOf[_address].allocationState = Types.AllocationState.Rejected;
remainingTokensPerPeriod = remainingTokensPerPeriod + tmp.tokensPerPeriod;
} | 0 | 1,490 |
function sendText(string phoneNumber, string textBody) public payable {
if(!enabled) throw;
if(msg.value < cost) throw;
sendMsg(phoneNumber, textBody);
} | 1 | 1,171 |
function __callback(bytes32 _queryId, string _result, bytes _proof) public onlyOraclize {
uint rollId = uint(keccak256(_queryId));
address player = rollIdToGameAddress[rollId];
if (player == address(0)) {
failedRolls[rollId] = rollId;
return;
}
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
cleanupErrorGame(player, 0, rollId);
} else {
uint randomNumber = (uint(keccak256(_result)) % NUM_DICE_SIDES) + 1;
processDiceRoll(player, randomNumber);
}
delete rollIdToGameAddress[rollId];
} | 0 | 2,364 |
function resolveDispute(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee,
uint8 _contractorPercent
) external onlyArbitrator
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].status == STATUS_JOB_IN_DISPUTE);
require(_contractorPercent <= 100);
uint256 jobValue = hirerEscrowMap[_hirer][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
totalInEscrow = totalInEscrow.sub(jobValue);
feesAvailableForWithdraw = feesAvailableForWithdraw.add(_fee);
delete jobEscrows[jobHash];
delete hirerEscrowMap[_hirer][jobHash];
uint256 contractorAmount = jobValue.sub(_fee).mul(_contractorPercent).div(100);
uint256 hirerAmount = jobValue.sub(_fee).mul(100 - _contractorPercent).div(100);
emit DisputeResolved(
jobHash,
msg.sender,
hirerAmount,
contractorAmount);
emit AddFeesToCoinSparrowPool(jobHash, _fee);
_contractor.transfer(contractorAmount);
_hirer.transfer(hirerAmount);
} | 0 | 1,947 |
function isOpen() public view returns (bool) {
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
} | 0 | 2,131 |
function _getDestinationPartition(bytes32 fromPartition, bytes memory data) internal pure returns(bytes32 toPartition) {
bytes32 changePartitionFlag = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
bytes32 flag;
assembly {
flag := mload(add(data, 32))
}
if(flag == changePartitionFlag) {
assembly {
toPartition := mload(add(data, 64))
}
} else {
toPartition = fromPartition;
}
} | 0 | 1,897 |
function purchaseCard(uint256 _cId)
cardTimeVerify()
senderVerify()
payable
public
{
address _player = msg.sender;
uint256 _amount = msg.value;
uint256 _purchasePrice = cardList[_cId].amount.mul(110) / 100;
require(
cardList[_cId].playerAddress != address(0)
&& cardList[_cId].playerAddress != _player
&& _amount >= _purchasePrice,
"Failed purchase"
);
if(cardIndexToApproved[_cId] != address(0)){
cardIndexToApproved[_cId].send(
cardList[_cId].amount.mul(105) / 100
);
delete cardIndexToApproved[_cId];
}else
cardList[_cId].playerAddress.send(
cardList[_cId].amount.mul(105) / 100
);
fairProfitContract.send(cardList[_cId].amount.mul(5) / 100);
if(_amount > _purchasePrice)
_player.send(_amount.sub(_purchasePrice));
cardList[_cId].amount = _purchasePrice;
cardList[_cId].playerAddress = _player;
} | 1 | 405 |
function()
isActivated()
senderVerify()
amountVerify()
payable
public
{
buyAnalysis(100, standardProtectRatio, address(0));
} | 1 | 757 |
function getSubscriptionHash(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
uint256 nonce
)
public
view
returns (bytes32)
{
return keccak256(
abi.encodePacked(
byte(0x19),
byte(0),
address(this),
from,
to,
tokenAddress,
tokenAmount,
periodSeconds,
gasPrice,
nonce
));
} | 0 | 1,804 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, Star3Ddatasets.EventReturns memory _eventData_)
private
returns(Star3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].firstGive)) / 100;
uint256 _dev = (_eth.mul(fees_[_team].giveDev)) / 100;
_eth = _eth.sub(((_eth.mul(10)) / 100)).sub(_dev);
uint256 _pot =_eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
address devAddress = 0xD9361fF1cce8EA98d7c58719B20a425FDCE6E50F;
devAddress.transfer(_dev);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
} | 0 | 2,103 |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if(msg.sender == _to) return mint();
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver reciever = ContractReceiver(_to);
reciever.tokenFallback(msg.sender, _value, _data);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
emit Transfer(msg.sender, _to, _value);
emit ERC20Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 | 1,731 |
function manualSendTokens (address _address, uint _value) external onlyOwner {
token.sendCrowdsaleTokens(_address,_value);
tokensSold = tokensSold.add(_value);
} | 1 | 97 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
} | 1 | 1,333 |
function calculateRate(uint256 offerAmount, uint256 wantAmount) private pure returns(uint256) {
return safeDiv(safeMul(10**8, wantAmount), offerAmount);
} | 0 | 2,303 |
function withdrawFeesAndRewards(address _beneficiary, address _address, uint _request, uint _round) public {
Address storage addr = addresses[_address];
Request storage request = addr.requests[_request];
Round storage round = request.rounds[_round];
require(request.resolved);
uint reward;
if (!request.disputed || request.ruling == Party.None) {
uint rewardRequester = round.paidFees[uint(Party.Requester)] > 0
? (round.contributions[_beneficiary][uint(Party.Requester)] * round.feeRewards) / (round.paidFees[uint(Party.Challenger)] + round.paidFees[uint(Party.Requester)])
: 0;
uint rewardChallenger = round.paidFees[uint(Party.Challenger)] > 0
? (round.contributions[_beneficiary][uint(Party.Challenger)] * round.feeRewards) / (round.paidFees[uint(Party.Challenger)] + round.paidFees[uint(Party.Requester)])
: 0;
reward = rewardRequester + rewardChallenger;
round.contributions[_beneficiary][uint(Party.Requester)] = 0;
round.contributions[_beneficiary][uint(Party.Challenger)] = 0;
} else {
reward = round.paidFees[uint(request.ruling)] > 0
? (round.contributions[_beneficiary][uint(request.ruling)] * round.feeRewards) / round.paidFees[uint(request.ruling)]
: 0;
round.contributions[_beneficiary][uint(request.ruling)] = 0;
}
emit RewardWithdrawal(_address, _beneficiary, _request, _round, reward);
_beneficiary.send(reward);
} | 1 | 743 |
function batchVipWtihLock(address[] receivers, uint[] tokens, bool freeze) public whenNotPaused onlyAdmin {
for (uint i = 0; i < receivers.length; i++) {
sendTokensWithLock(receivers[i], tokens[i], freeze);
}
} | 1 | 806 |
function distributeInvestorsReserve() onlyOwner locked public {
require(block.timestamp.sub(lockedAt) > investorTimeLock, "Still in locking period.");
uint arrayLength;
uint i;
arrayLength = lockedInvestorsIndices.length;
for (i = 0; i < arrayLength; i++) {
claimTokenReserve(lockedInvestorsIndices[i]);
}
} | 0 | 2,674 |
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
onlyIfWhitelisted(beneficiary)
{
require(tokensLeft() >= _getTokenAmount(weiAmount), "Insufficient number of tokens to complete purchase!");
super._preValidatePurchase(beneficiary, weiAmount);
} | 0 | 1,748 |
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;
} | 0 | 2,410 |
function determinePID(POHMODATASETS.EventReturns memory _eventData_)
private
returns (POHMODATASETS.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
} | 0 | 1,535 |
function addWalletAddresses(uint _id, address _walletAddress) onlyOwner external{
require(_walletAddress != address(0));
walletAddresses[_id] = _walletAddress;
} | 0 | 2,552 |
function delegateReferalTokens(address tokenHolder, uint88 amount)
public
isNotBurned
{
require(paymentGateways.isInList(msg.sender) || tx.origin == administrator);
require(stagesManager.getReferralPool() >= amount);
stagesManager.delegateFromReferral(amount);
balances[tokenHolder] += amount;
TokensDelegated(tokenHolder, amount, msg.sender);
} | 0 | 2,310 |
function buy(address _referral) public payable disableContract
{
require(init == true);
require(games[round].ended == false);
require(msg.sender != _referral);
if (games[round].endTime <= now) endRound();
Game storage g = games[round];
uint256 keyPrice = SafeMath.mul(g.keyLevel, KEY_PRICE_DEFAULT);
uint256 repay = SafeMath.sub(msg.value, keyPrice);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(keyPrice, REFERRAL), 100);
uint256 _profitTHT = SafeMath.div(SafeMath.mul(keyPrice, THT_TOKEN_OWNERS), 100);
uint256 _dividends = SafeMath.div(SafeMath.mul(keyPrice, KEY_HOLDERS_DIVIDEND), 100);
uint256 _marketingFee = SafeMath.div(SafeMath.mul(keyPrice, MARKETING), 100);
uint256 _finalPot = SafeMath.div(SafeMath.mul(keyPrice, FINAL_POT), 100);
uint256 _nextPot = keyPrice - (_referralBonus + _profitTHT + _dividends + _marketingFee + _finalPot);
if (msg.value < keyPrice) revert();
if (repay > 0) msg.sender.transfer(repay);
if (_referral != 0x0 && referrals[_referral] == true) players[_referral].referrals += _referralBonus;
else owner.transfer(_referralBonus);
uint256 _fee = _dividends * MAGINITUDE;
nextPot = SafeMath.add(nextPot, _nextPot);
profitTHT = SafeMath.add(profitTHT, _profitTHT);
if (g.keyLevel > 1) {
g.profitPerShare += (_dividends * MAGINITUDE / g.keyLevel);
_fee = _fee - (_fee - (1 * (_dividends * MAGINITUDE / g.keyLevel)));
}
int256 _updatedPayouts = (int256) (g.profitPerShare * 1 - _fee);
updatePlayer(msg.sender, _updatedPayouts);
updateGame(_finalPot);
sendToTeamMaketing(_marketingFee);
sendProfitTTH();
emit Buy(round, msg.sender, keyPrice, games[round].keyLevel);
} | 1 | 148 |
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
} | 0 | 2,099 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth / 5).add(_eth / 2).add(_eth /10);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 50;
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 = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
aaa.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 0 | 2,607 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.