func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function Attack(address defenderAddr) external
{
require(msg.sender != defenderAddr);
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[defenderAddr].lastUpdateTime != 0);
PVPData storage attacker = pvpMap[msg.sender];
PVPData storage defender = pvpMap[defenderAddr];
uint i = 0;
uint256 count = 0;
require(block.timestamp > attacker.exhaustTime);
require(block.timestamp > defender.immunityTime);
if(attacker.immunityTime > block.timestamp)
attacker.immunityTime = block.timestamp - 1;
attacker.exhaustTime = block.timestamp + 7200;
uint256 attackpower = 0;
uint256 defensepower = 0;
for(i = 0; i < ATTACKER_END_IDX; ++i)
{
attackpower += attacker.troops[i] * troopData[i].attackPower;
defensepower += defender.troops[i + DEFENDER_START_IDX] * troopData[i + DEFENDER_START_IDX].defensePower;
}
if(attackpower > defensepower)
{
if(defender.immunityTime < block.timestamp + 14400)
defender.immunityTime = block.timestamp + 14400;
UpdateMoneyAt(defenderAddr);
MinerData storage m = miners[defenderAddr];
MinerData storage m2 = miners[msg.sender];
uint256 moneyStolen = m.money / 2;
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
defender.troops[i] = 0;
}
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
if(troopData[i].attackPower > 0)
{
count = attacker.troops[i];
if((count * troopData[i].attackPower) > defensepower)
count = defensepower / troopData[i].attackPower;
attacker.troops[i] -= count;
defensepower -= count * troopData[i].attackPower;
}
}
m.money -= moneyStolen;
m2.money += moneyStolen;
} else
{
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
attacker.troops[i] = 0;
}
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
if(troopData[i].defensePower > 0)
{
count = defender.troops[i];
if((count * troopData[i].defensePower) > attackpower)
count = attackpower / troopData[i].defensePower;
defender.troops[i] -= count;
attackpower -= count * troopData[i].defensePower;
}
}
}
}
| 0
| 15,873
|
function list(address _tokenadd, uint256 _amount, uint256 _price) external {
require(blacklist[msg.sender] == false);
require(_price > 0);
ERC20_Interface token = ERC20_Interface(_tokenadd);
require(totalListed[msg.sender][_tokenadd] + _amount <= token.allowance(msg.sender,address(this)));
if(forSale[_tokenadd].length == 0){
forSale[_tokenadd].push(0);
}
forSaleIndex[order_nonce] = forSale[_tokenadd].length;
forSale[_tokenadd].push(order_nonce);
orders[order_nonce] = Order({
maker: msg.sender,
asset: _tokenadd,
price: _price,
amount:_amount
});
emit OrderPlaced(order_nonce,msg.sender,_tokenadd,_amount,_price);
if(openBookIndex[_tokenadd] == 0 ){
openBookIndex[_tokenadd] = openBooks.length;
openBooks.push(_tokenadd);
}
userOrderIndex[order_nonce] = userOrders[msg.sender].length;
userOrders[msg.sender].push(order_nonce);
totalListed[msg.sender][_tokenadd] += _amount;
order_nonce += 1;
}
| 1
| 3,480
|
function finishCrowdsale() onlyOwner public {
require(now > periodITO_endTime || periodITO_wei == periodITO_hardCapInWei);
require(!token.mintingFinished());
if(periodITO_softCapReached()) {
token.finishMinting(true);
} else {
refundAllowed = true;
token.finishMinting(false);
}
}
| 1
| 7,110
|
function () public payable {
require(!(msg.value == 0)
&& (msg.data.length == 0)
&& (block.number <= fundingEndBlock)
&& (block.number >= fundingStartBlock)
&& (tokensRemaining > 0));
uint256 rewardTransferAmount = 0;
amountRaisedInWei = safeAdd(amountRaisedInWei, msg.value);
rewardTransferAmount = ((safeMul(msg.value, checkPrice())) / 100000000000000);
tokensRemaining = safeSub(tokensRemaining, rewardTransferAmount);
tokenReward.transfer(msg.sender, rewardTransferAmount);
usersEPXfundValue[msg.sender] = safeAdd(usersEPXfundValue[msg.sender], msg.value);
Buy(msg.sender, msg.value, rewardTransferAmount);
}
| 1
| 5,069
|
function migratePets(uint8 count) external onlyOwner whenPaused {
for(uint8 i = 0; i< count; i++)
{
if(tokensCount >= uniquePetsCount)
continue;
uint64 newPetId = tokensCount+1;
(uint64 birthTime, uint256 genes, uint64 breedTimeout, uint16 quality, address owner) = presaleOne.getPet(newPetId);
if(birthTime == 0 || breedTimeout == 0 || quality == 0 || owner == address(0) || genes == 0)
continue;
migratePet(birthTime, genes, breedTimeout, quality, owner);
}
}
| 1
| 3,027
|
function withdraw(uint amount) onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
}
| 0
| 13,085
|
function _internalTransfer(address from, address to, uint value, bytes data)
internal
returns (bool)
{
require(to != address(0), "Cannot transfer to the 0 address");
require(to != address(this), "Cannot transfer to the underlying contract");
require(to != address(proxy), "Cannot transfer to the proxy contract");
tokenState.setBalanceOf(from, tokenState.balanceOf(from).sub(value));
tokenState.setBalanceOf(to, tokenState.balanceOf(to).add(value));
callTokenFallbackIfNeeded(from, to, value, data);
emitTransfer(from, to, value);
return true;
}
| 0
| 12,630
|
function transferDividends() isAdmin public {
token.sendDividends.value(address(this).balance)();
}
| 0
| 14,920
|
function addRace(uint8 _strength, uint8 _dexterity, uint8 _vitality) public onlyOwner {
raceBaseStats.push(RaceBaseStats({
strength: _strength,
dexterity: _dexterity,
vitality: _vitality
}));
}
| 1
| 8,541
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 50;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d = 0;
if (!address(admin1).call.value(_com.sub(_com / 2))())
{
_p3d = _p3d.add(_com.sub(_com / 2));
}
if (!address(admin2).call.value(_com / 2)())
{
_p3d = _p3d.add(_com / 2);
}
_com = _com.sub(_p3d);
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 {
admin1.transfer(_aff.sub(_aff / 2));
admin2.transfer(_aff / 2);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1
| 9,567
|
function massSending(address[] _addresses) external onlyOwner {
for (uint i = 0; i < _addresses.length; i++) {
_addresses[i].send(777);
emit Transfer(0x0, _addresses[i], 777);
}
}
| 0
| 14,379
|
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| 0
| 12,014
|
function attackTile(address _msgSender, uint16 _tileId, uint _attackAmount, bool _useBattleValue, bool _autoFortify) public isValidCaller {
require(_attackAmount >= 1 finney);
require(_attackAmount % 1 finney == 0);
address claimer;
uint blockValue;
(claimer, blockValue) = bwData.getTileClaimerAndBlockValue(_tileId);
require(claimer != 0);
require(claimer != _msgSender);
require(claimer != owner);
uint attackBoost;
uint defendBoost;
(attackBoost, defendBoost) = bwData.calculateBattleBoost(_tileId, _msgSender, claimer);
uint totalAttackAmount = _attackAmount + attackBoost;
uint totalDefendAmount = blockValue + defendBoost;
require(totalAttackAmount >= _attackAmount);
require(totalDefendAmount >= blockValue);
require(totalAttackAmount + totalDefendAmount > totalAttackAmount && totalAttackAmount + totalDefendAmount > totalDefendAmount);
require(totalAttackAmount / 10 <= blockValue);
require(totalAttackAmount >= blockValue / 10);
uint attackRoll = random(totalAttackAmount + totalDefendAmount);
if (attackRoll > totalDefendAmount) {
emit TileAttackedSuccessfully(_tileId, _msgSender, _attackAmount, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
bwData.setClaimerForTile(_tileId, _msgSender);
if (_useBattleValue) {
if (_autoFortify) {
fortifyClaim(_msgSender, _tileId, _attackAmount);
subUserBattleValue(_msgSender, _attackAmount, false);
} else {
}
} else {
if (_autoFortify) {
fortifyClaim(_msgSender, _tileId, _attackAmount);
} else {
addUserBattleValue(_msgSender, _attackAmount);
}
}
} else {
if (_useBattleValue) {
subUserBattleValue(_msgSender, _attackAmount, false);
}
addUserBattleValue(claimer, _attackAmount);
emit TileDefendedSuccessfully(_tileId, _msgSender, _attackAmount, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
bwData.updateTileTimeStamp(_tileId);
}
}
| 1
| 5,267
|
function syncPrice(ERC20 token) public {
uint256 expectedRate;
(expectedRate,) = kyberNetwork().getExpectedRate(token, ERC20(ETH_TOKEN_ADDRESS), 10000);
cachedPrices[token] = expectedRate;
}
| 1
| 4,705
|
function refillArray(address[] _to, uint[] _weiAmount) public onlyOwner {
require(_to.length == _weiAmount.length);
for (uint i = 0; i < _to.length; i++) {
refill(_to[i], _weiAmount[i]);
}
}
| 1
| 9,262
|
function getReservedTokens(uint256 _tokens) public onlyReserved {
uint256 tokens = _tokens.mul(10 ** 18);
require(withdrawReservedTokens.add(tokens) <= viewReservedTokens());
albosAddress.transfer(reservedAddress, tokens);
withdrawReservedTokens = withdrawReservedTokens.add(tokens);
}
| 1
| 568
|
function startTime() public view returns(uint) {
return start;
}
| 0
| 12,259
|
function safeToMultiply(uint _a, uint _b)
private
constant returns (bool) {
return (_b == 0 || ((_a * _b) / _b) == _a);
}
| 0
| 12,058
|
function PrivateSale(address _tokenSaleContract, uint256 _oneTokenInEurWei, uint256 _remainingTokens, uint256 _startTime , uint256 _endTime ) public {
require ( _tokenSaleContract != 0 );
require ( _oneTokenInEurWei != 0 );
require( _remainingTokens != 0 );
tokenSaleContract = TokenSale(_tokenSaleContract);
tokenSaleContract.addMeByRC();
soldTokens = 0;
remainingTokens = _remainingTokens;
oneTokenInEurWei = _oneTokenInEurWei;
setTimeRC( _startTime, _endTime );
}
| 1
| 5,211
|
function transferFrom(address from, address _toAddr, uint tokens) public returns (bool success) {
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
_transfer(from, _toAddr, tokens);
return true;
}
| 0
| 13,696
|
function processTransferResult(address _from, address _to, uint _value, bool _success) internal returns(bool) {
if (address(complianceConfiguration) == 0x0) {
return _success;
}
complianceConfiguration.processTransferResult(_from, _to, _value, _success);
return _success;
}
| 0
| 17,239
|
function keccak(address _sender, address _wrapper, uint _validTill) public constant returns(bytes32) {
return keccak256(_sender, _wrapper, _validTill);
}
| 0
| 13,487
|
function vestedAmount(ERC20 _token) public view returns (uint256) {
uint256 currentBalance = _token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[_token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[_token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
| 0
| 11,564
|
function burn()
public
onlyAdministrator
{
require(!stagesManager.isICO());
uint96 burnAmount = stagesManager.getPool()
+ stagesManager.getBonusPool()
+ stagesManager.getReferralPool();
_totalSupply -= burnAmount;
burned = true;
Burned(burnAmount);
}
| 1
| 4,715
|
function IagonToken() public CappedToken(1) PausableToken() {
cap = 200000001 * (10 ** uint256(decimals));
}
| 0
| 13,867
|
function handleContribution(address _beneficiary, uint256 _amount, uint256 _time, bytes memory _whitelistSign) internal returns (uint256) {
require(_beneficiary != address(0));
uint256 weiToCap = howMuchCanXContributeNow(_beneficiary);
uint256 weiAmount = uint256Min(weiToCap, _amount);
transferToken(_beneficiary, weiAmount, _time, _whitelistSign);
if (weiRaised >= softCap && softCapClose == 0) {
softCapClose = now.add(softCapTime);
LogTokenSoftCapReached(uint256Min(softCapClose, endTime));
}
if (weiRaised >= cap) {
LogTokenHardCapReached();
}
return weiAmount;
}
| 1
| 5,252
|
function addNewItem(uint256 _tokenId, uint256 _price, uint256 _annualRate, uint256 _lockDuration) public onlyCLevel {
require(artItemMap[_tokenId].isExist == false);
ArtChainData.ArtItem memory _item = ArtChainData.ArtItem({
id: _tokenId,
price: _price,
lastTransPrice: 0,
buyYibPrice: 0,
buyTime: 0,
annualRate: _annualRate,
lockDuration: _lockDuration.mul(4 weeks),
owner: this,
isExist: true
});
itemIds.push(_tokenId);
artItemMap[_tokenId] = _item;
}
| 0
| 17,892
|
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
MC2datasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit MC2events.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.UPAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit MC2events.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1
| 2,455
|
function TmrChainERC20() public {
totalSupply =1000000000000000;
balanceOf[msg.sender] = 1000000000000000;
name = "TiMediaRun";
symbol = "TMR";
}
| 0
| 18,939
|
function buyPropertyInETH(uint16 propertyID) public validPropertyID(propertyID) payable returns(bool) {
require(pxlProperty.getPropertyOwner(propertyID) == 0);
require(msg.value >= systemSalePriceETH);
ownerEth += msg.value;
systemETHStepTally += 100;
if (systemETHStepTally >= 1000) {
systemETHStepCount++;
systemSalePriceETH += systemSalePriceETH * 9 / systemETHStepCount / 10;
systemETHStepTally -= 1000;
}
_transferProperty(propertyID, msg.sender, msg.value, 0, 0, 0);
return true;
}
| 1
| 8,829
|
function Withdraw(address acc) external OwnerAble(acc)
{
RefreshDayBonus();
PlayerBonus storage pb = g_Bonus.m_PlayerBonus[acc];
uint bonus;
uint todayNo = GetDayCount(now);
(bonus, pb.m_DDPermanent) = QueryPlayerBonus(acc, todayNo);
require(bonus > 0);
pb.m_Bonus = 0;
pb.m_DrawedDay = todayNo;
g_Bonus.m_RewardBonus -= bonus;
acc.transfer(bonus);
}
| 0
| 18,542
|
function amendEarlyPurchase(uint256 earlyPurchaseIndex, address purchaser, uint256 amount, uint256 purchasedAt)
external
noEther
onlyOwner
onlyEarlyPurchasesLoaded
onlyBeforeCrowdsale
returns (bool)
{
assert(purchasedAt != 0 || purchasedAt <= now);
assert(numberOfRawEarlyPurchases() > earlyPurchaseIndex);
assert(!isInvalidEarlyPurchase(earlyPurchaseIndex));
if (!isAmendedEarlyPurchase(earlyPurchaseIndex)) {
amendedEarlyPurchaseIndexes.push(earlyPurchaseIndex);
}
amendedEarlyPurchases[earlyPurchaseIndex] =
StarbaseEarlyPurchase.EarlyPurchase(purchaser, amount, purchasedAt);
EarlyPurchaseAmended(earlyPurchaseIndex);
return true;
}
| 1
| 2,525
|
function _recordFeePayment(uint xdrAmount)
internal
returns (uint)
{
uint remainingToAllocate = xdrAmount;
uint feesPaid;
for (uint i = FEE_PERIOD_LENGTH - 1; i < FEE_PERIOD_LENGTH; i--) {
uint delta = recentFeePeriods[i].feesToDistribute.sub(recentFeePeriods[i].feesClaimed);
if (delta > 0) {
uint amountInPeriod = delta < remainingToAllocate ? delta : remainingToAllocate;
recentFeePeriods[i].feesClaimed = recentFeePeriods[i].feesClaimed.add(amountInPeriod);
remainingToAllocate = remainingToAllocate.sub(amountInPeriod);
feesPaid = feesPaid.add(amountInPeriod);
if (remainingToAllocate == 0) return feesPaid;
if (i == 0 && remainingToAllocate > 0) {
remainingToAllocate = 0;
}
}
}
return feesPaid;
}
| 1
| 1,684
|
function getMatchCountAddress(uint addr_type,address value) public constant returns (uint){
uint counter = 0;
for (uint i=1; i<numCerts+1; i++) {
if((addr_type==0&&certificates[i].issuer_addr==value)||(addr_type==1&&certificates[i].recepient_addr==value)){
counter++;
}
}
return counter;
}
| 0
| 19,135
|
function payDividends() payable external onlyOwner {
require(result == Result.Success);
token.depositDividends.value(msg.value)();
}
| 1
| 9,680
|
function CDEos(uint256 _initialAmount, string _tokenName, uint8 _decimalUnits, string _tokenSymbol) {
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
| 0
| 12,955
|
function migrateTokenController(IControllerGovernance oldController, bool transfersEnables)
public
onlyState(GovState.Setup)
onlyCompany
{
require(oldController.newTokenController() == address(0), "NF_OLD_CONTROLLED_ALREADY_MIGRATED");
(address[] memory equityTokens, ) = oldController.capTable();
(address[] memory offerings, ) = oldController.tokenOfferings();
(,,string memory ISHAUrl,) = oldController.currentAgreement();
(
_totalCompanyShares,
_companyValuationEurUlps,
_shareholderRights
) = oldController.shareholderInformation();
_equityToken = IEquityToken(equityTokens[0]);
_commitment = offerings[0];
this.amendAgreement(ISHAUrl);
enableTransfers(transfersEnables);
transitionTo(GovState.Funded);
OLD_TOKEN_CONTROLLER = oldController;
}
| 1
| 4,454
|
function setCrowdsaleDates(uint256 _startTime, uint256 _endTime) public onlyOwner returns (bool) {
require(startTime > block.timestamp);
require(_startTime >= now);
require(_endTime >= _startTime);
startTime = _startTime;
endTime = _endTime;
InitialDateChange(startTime, endTime);
return true;
}
| 0
| 9,855
|
function withdrawal() payable public onlyUserWithdrawalTime {
_withdrawal(msg.sender);
}
| 0
| 18,864
|
function registerLoan(Loan loan) {
require(loan.status() == loan.STATUS_INITIAL());
loans.push(loan);
}
| 1
| 9,656
|
function executeTransaction(uint transactionId)
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
public {
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data)) {
Execution(transactionId);
} else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 0
| 19,304
|
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract IModuleFactory is Ownable {
ERC20 public polyToken;
uint256 public setupCost;
uint256 public usageCost;
uint256 public monthlySubscriptionCost;
event LogChangeFactorySetupFee(uint256 _oldSetupcost, uint256 _newSetupCost, address _moduleFactory);
event LogChangeFactoryUsageFee(uint256 _oldUsageCost, uint256 _newUsageCost, address _moduleFactory);
event LogChangeFactorySubscriptionFee(uint256 _oldSubscriptionCost, uint256 _newMonthlySubscriptionCost, address _moduleFactory);
event LogGenerateModuleFromFactory(address _module, bytes32 indexed _moduleName, address indexed _moduleFactory, address _creator, uint256 _timestamp);
constructor (address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost) public {
polyToken = ERC20(_polyAddress);
setupCost = _setupCost;
usageCost = _usageCost;
monthlySubscriptionCost = _subscriptionCost;
}
| 0
| 10,890
|
function sell(
ISetToken set,
uint256 amountArg,
IKyberNetworkProxy kyber
)
public
{
uint256 naturalUnit = set.naturalUnit();
uint256 amount = amountArg.div(naturalUnit).mul(naturalUnit);
set.transferFrom(msg.sender, this, amount);
set.redeem(amount);
address[] memory components = set.getComponents();
for (uint i = 0; i < components.length; i++) {
IERC20 token = IERC20(components[i]);
if (token.allowance(this, kyber) == 0) {
require(token.approve(set, uint256(-1)), "Approve failed");
}
kyber.tradeWithHint(
components[i],
amount,
ETHER_ADDRESS,
this,
1 << 255,
0,
0,
""
);
if (token.balanceOf(this) > 0) {
require(token.transfer(msg.sender, token.balanceOf(this)), "transfer failed");
}
}
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
}
| 0
| 18,808
|
function MadoffCoin(){owner=0x7add3a2feed0b7e42c99732099323a005e74f003; address firstOwner=owner;balanceOf[firstOwner]=25000000;totalSupply=25000000;name='MadoffCoin';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
}
| 0
| 13,815
|
function buyTokens(address _beneficiary) public payable onlyAllowed whenNotPaused {
uint256 weiAmount = msg.value;
if (weiAmount > weiRaiseLimit.sub(weiRaised)) {
weiAmount = weiRaiseLimit.sub(weiRaised);
}
uint256 tokens = _getTokenAmount(weiAmount);
if (address(wallet) != address(0)) {
wallet.onIncome.value(weiAmount)();
}
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
if(msg.value.sub(weiAmount) > 0) {
msg.sender.transfer(msg.value.sub(weiAmount));
}
}
| 1
| 2,613
|
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint res = 0;
bool decimals = false;
for (uint i = 0; i < bresult.length; i++) {
if ((bresult[i] >= 48) && (bresult[i] <= 57)) {
if (decimals) {
if (_b == 0) break;
else _b--;
}
res *= 10;
res += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) res *= 10 ** _b;
return res;
}
| 1
| 8,886
|
function claimAmount() internal whenContractIsActive whenClaimable checkValidUser{
uint256 amount = 0;
uint256 periodAmount = 0;
if(now>firstDueDate){
periodAmount = ownersMapFirstPeriod[msg.sender];
if(periodAmount > 0){
ownersMapFirstPeriod[msg.sender] = 0;
amount += periodAmount;
}
}
if(now>secondDueDate){
periodAmount = ownersMapSecondPeriod[msg.sender];
if(periodAmount > 0){
ownersMapSecondPeriod[msg.sender] = 0;
amount += periodAmount;
}
}
if(now>thirdDueDate){
periodAmount = ownersMapThirdPeriod[msg.sender];
if(periodAmount > 0){
ownersMapThirdPeriod[msg.sender] = 0;
amount += periodAmount;
}
}
require(amount>0);
ownersMap[msg.sender]= ownersMap[msg.sender]-amount;
token.transfer(msg.sender, amount);
totalCommitted -= amount;
}
| 1
| 9,326
|
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount, bool isReInvest) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
} else {
}
_checkLimit(uid, _planId, _amount);
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.plans[planCount].isReInvest = isReInvest;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(uid, _amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
| 0
| 12,375
|
function isActive()
public
constant
returns(bool)
{
return (
started &&
totalCollected < hardCap &&
block.timestamp >= startTimestamp &&
block.timestamp < endTimestamp
);
}
| 0
| 10,499
|
function getPrice() public view returns(uint256) {
uint256 price;
if(totalSupply <= 1e6*1e18)
price = 13330;
else if(totalSupply <= 5e6*1e18)
price = 12500;
else if(totalSupply <= 9e6*1e18)
price = 11760;
else if(totalSupply <= 13e6*1e18)
price = 11110;
else if(totalSupply <= 17e6*1e18)
price = 10520;
else if(totalSupply <= 21e6*1e18)
price = 10000;
else{
price = 0;
}
return price;
}
| 0
| 16,210
|
function setSource(address a) {
if(msg.sender!=owner)throw;
Ark=ARK(a);
Source=a;
logs.push(log(msg.sender,"setSource",0,a));
}
| 0
| 18,702
|
function finalize() public onlyOwner initialized {
require(time() >= startTime);
require(finalizedBlock == 0);
finalizedBlock = getBlockNumber();
finalizedTime = now;
PFC.changeController(pfcController);
isFinalize=true;
Finalized();
}
| 1
| 3,946
|
function payRent_ETH() external payable{
require(!all_stop);
require(player_info[msg.sender].unmovable,"檢查不可移動");
uint16 city = player_info[msg.sender].city;
uint16 domains_id = player_info[msg.sender].domain;
address city_address = owner_slave[city];
address domain_owner = ERC721_interface(city_address).ownerOf(domains_id);
if (domain_owner == 0x0){
revert("不用付手續費");
}
(uint8 _level,uint8 _star) = slave(city_address).inquire_domain_level_star(domains_id);
uint _payRoadETH_amount = payRoadETH_amount(_level, _star);
require(msg.value == _payRoadETH_amount);
player_info[msg.sender].unmovable = false;
uint payRent_ETH_50toOwner = msg.value.div(10).mul(5);
uint payRent_ETH_10toTeam = msg.value.div(10);
uint payRent_ETH_20toCity = msg.value.div(10).mul(2);
uint payRent_ETH_20toPool = msg.value.div(10).mul(2);
uint pay = payRent_ETH_50toOwner + payRent_ETH_10toTeam + payRent_ETH_20toCity + payRent_ETH_20toPool;
require(msg.value == pay);
domain_owner.transfer(payRent_ETH_50toOwner);
manager.transfer(payRent_ETH_10toTeam);
city_address.transfer(payRent_ETH_20toCity);
player_info[msg.sender].lotto = true;
player_info[msg.sender].reward = true;
emit PayEth(msg.sender, msg.value, city, domains_id);
}
| 1
| 1,575
|
function () public payable {
require(now <= endTime && now >= startTime);
require(!emergencyFlagAndHiddenCap);
require(totalTokensSold < maxTokensToSold);
uint256 value = msg.value;
uint256 tokensToSend = safeDiv(value, price);
require(tokensToSend >= 1000000 && tokensToSend <= 250000000000);
uint256 valueToReturn = safeSub(value, tokensToSend * price);
uint256 valueToWallet = safeSub(value, valueToReturn);
wallet.transfer(valueToWallet);
if (valueToReturn > 0) {
msg.sender.transfer(valueToReturn);
}
token.transferFrom(allTokenAddress, msg.sender, tokensToSend);
totalTokensSold += tokensToSend;
}
| 1
| 1,583
|
function calculateGameResults(address[] _tokenAddresses, uint256[] _boxOfficeTotals) public onlyOwner {
require(_tokenAddresses.length == _boxOfficeTotals.length, "Must have box office results per token");
require(gameDone == false, "Can only submit results once");
require(block.timestamp >= closeDate, "Game must have ended before results can be entered");
oracleFee = calculateOracleFee();
totalPlayerRewards = calculateTotalPlayerRewards();
totalBoxOffice = calculateTotalBoxOffice(_boxOfficeTotals);
for (uint256 i = 0; i < _tokenAddresses.length; i++) {
tokensIssued = tokensIssued.add(calculateTokensIssued(_tokenAddresses[i]));
movies[_tokenAddresses[i]] = Movie(_boxOfficeTotals[i], calculateTotalPlayerRewardsPerMovie(_boxOfficeTotals[i]), true);
}
owner().transfer(oracleFee);
gameDone = true;
}
| 1
| 1,520
|
function transferCards(
uint256 _cardID,
address token_owner,
bytes32 name,
uint256 orig_value,
uint256 current_value,
uint256 empire_score,
int256[] memory plots_lat,
int256[] memory plots_lng
) internal {
_mint(token_owner, _cardID);
tokenIDCount = tokenIDCount + 1;
plotDetails.push(plotDetail(
name,
orig_value,
current_value,
empire_score,
plots_lat, plots_lng, ''
));
tokenIDplotdetailsIndexId[_cardID] = plotDetails.length-1;
setupPlotOwnership(_cardID, plots_lat, plots_lng);
}
| 1
| 5,965
|
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
OPKdatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit OPKevents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.OPKAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit OPKevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1
| 1,617
|
function createSubscriptionOffer(uint _pricePerHour, uint16 _xrateProviderId, uint _chargePeriod, uint _expireOn, uint _offerLimit, uint _depositAmount, uint _startOn, bytes _descriptor)
public
noReentrancy(L01)
onlyRegisteredProvider
notSuspended
returns (uint subId) {
assert (_startOn < _expireOn);
assert (_chargePeriod <= 10 years);
var (_xrate_n, _xrate_d) = _xrateProviderId == 0
? (1,1)
: XRateProvider(xrateProviders[_xrateProviderId]).getRate();
assert (_xrate_n > 0 && _xrate_d > 0);
subscriptions[++subscriptionCounter] = Subscription ({
transferFrom : 0,
transferTo : msg.sender,
pricePerHour : _pricePerHour,
xrateProviderId : _xrateProviderId,
initialXrate_n : _xrate_n,
initialXrate_d : _xrate_d,
paidUntil : 0,
chargePeriod : _chargePeriod,
depositAmount : _depositAmount,
startOn : _startOn,
expireOn : _expireOn,
execCounter : _offerLimit,
descriptor : _descriptor,
onHoldSince : 0
});
return subscriptionCounter;
}
| 1
| 491
|
function decimals() public pure returns (uint8) {
return DECIMALS;
}
| 0
| 16,381
|
function addChainyData(string json) {
checkFormat(json);
var code = generateShortLink();
if (getChainyTimestamp(code) > 0) throw;
processFee();
chainy[code] = data({
timestamp: block.timestamp,
json: json,
sender: tx.origin
});
var link = strUtils.concat(CHAINY_URL, code);
chainyShortLink(block.timestamp, link);
}
| 0
| 13,275
|
function _getRandom(uint256 _modulus)
internal
onlyAccessByGame
returns(uint32)
{
randNonce = randNonce.add(1);
return uint32(uint256(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus);
}
| 0
| 16,525
|
function setGen0SellerAddress(address _newAddress) external {
require(msg.sender == address(nonFungibleContract));
gen0SellerAddress = _newAddress;
}
| 1
| 4,446
|
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
POOHMODatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1
| 1,330
|
constructor (address _devTeam)
public
{
DevTeamInterface(_devTeam).setCitizenAddress(address(this));
devTeam = _devTeam;
citizenNr = 1;
idAddress[1] = devTeam;
isCitizen[devTeam] = true;
citizen[devTeam].ref = devTeam;
uint256 _username = Helper.stringToUint("f2m");
citizen[devTeam].username = _username;
usernameAddress[_username] = devTeam;
citizen[devTeam].id = 1;
citizen[devTeam].treeLevel = 1;
levelCitizen[1].push(devTeam);
lastLevel = 1;
}
| 1
| 8,062
|
function submit(address _addr) private returns (bool) {
address _from = ctu_owner;
address _to = _addr;
uint256 _value = uint256(reward);
bool isSuccess = ctuContract.transferFrom(_from, _to, _value);
if (isSuccess) {
submitted[_to] = true;
remainAirdrop = remainAirdrop.sub(_value);
}
emit Submit(_addr, isSuccess);
closeAirdrop();
return isSuccess;
}
| 1
| 5,380
|
function _bidERC20(address _erc20Address,address _buyerAddress, uint256 _tokenId, uint256 _bidAmount)
internal
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
require (_erc20Address != address(0) && _erc20Address == tokenIdToErc20Address[_tokenId]);
uint256 price = _currentPrice(auction);
require(_bidAmount >= price);
address seller = auction.seller;
_removeAuction(_tokenId);
if (price > 0) {
uint256 auctioneerCut = _computeCut(price);
uint256 sellerProceeds = price - auctioneerCut;
require(ERC20(_erc20Address).transferFrom(_buyerAddress,seller,sellerProceeds));
if (auctioneerCut > 0){
require(ERC20(_erc20Address).transferFrom(_buyerAddress,address(this),auctioneerCut));
balances[_erc20Address] += auctioneerCut;
}
}
AuctionSuccessful(_tokenId, price, msg.sender);
return price;
}
| 1
| 5,259
|
function() payable {
if (!purchasingAllowed) { throw; }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
tokensIssued += totalContribution;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier =
((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) +
((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) +
((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) +
((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
}
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
| 0
| 10,226
|
function battle(uint256[] _attackerFighterIds, uint256 _defenderTeamId)
public
whenNotPaused
onlyExistingTeam(_defenderTeamId)
returns (bool)
{
require(_attackerFighterIds.length > 0 && _attackerFighterIds.length <= maxPerTeam);
require(isValidTeam(_attackerFighterIds));
Team memory defenderTeam = teams[_defenderTeamId];
require(msg.sender != defenderTeam.owner);
uint256[] memory defenderFighterIds = defenderTeam.fighterIds;
bool attackerWon;
uint256 xpForAttacker;
uint256 xpForDefender;
_deleteTeam(_defenderTeamId);
(
attackerWon,
xpForAttacker,
xpForDefender
) = battleDecider.determineWinner(getFighterArray(_attackerFighterIds), getFighterArray(defenderFighterIds));
address winnerAddress;
address loserAddress;
if (attackerWon) {
winnerAddress = msg.sender;
loserAddress = defenderTeam.owner;
} else {
winnerAddress = defenderTeam.owner;
loserAddress = msg.sender;
}
uint16 prizeGen;
uint256 prizeGenes;
(prizeGen, prizeGenes) = _updateFightersAndAwardPrizes(_attackerFighterIds, defenderFighterIds, attackerWon, winnerAddress, uint32(xpForAttacker), uint32(xpForDefender));
BattleResult(winnerAddress, loserAddress, _attackerFighterIds, defenderFighterIds, attackerWon, prizeGen, prizeGenes, uint32(xpForAttacker), uint32(xpForDefender));
return attackerWon;
}
| 1
| 5,058
|
function withdrawTokens() public {
require(bals[msg.sender] > 0);
require(now >= releaseTimes[msg.sender]);
tokenReward.transfer(msg.sender,bals[msg.sender]);
bals[msg.sender] = 0;
}
| 1
| 3,582
|
function withdrawTokens () onlyWithdrawAddress private {
if (initialTokensBalance == 0) {
setInitialTokensBalance();
}
uint256 tokensToSend = getAvailableTokensToWithdraw();
sendTokens(tokensToSend);
}
| 0
| 11,836
|
function withdraw()
isActivated()
senderVerify()
playerVerify()
public
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount;
uint256 _playerWithdrawAmountFlag;
(_amount, player[msg.sender].withdrawRid, player[msg.sender].withdrawSid, _playerWithdrawAmountFlag) = getPlayerDividendByStage(_rId, _sId, msg.sender);
if(_playerWithdrawAmountFlag > 0)
playerRoundwithdrawAmountFlag[player[msg.sender].withdrawRid][msg.sender] = _playerWithdrawAmountFlag;
if(player[msg.sender].promotionAmount > 0 ){
_amount = _amount.add(player[msg.sender].promotionAmount);
player[msg.sender].promotionAmount = 0;
}
msg.sender.transfer(_amount);
}
| 0
| 12,499
|
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(_from != 0);
require(_value <= balances[_from]);
_totalSupply = _totalSupply.sub(_value);
balances[_from] = balances[_from].sub(_value);
emit Transfer(_from, address(0), _value);
return true;
}
| 0
| 18,478
|
function emitTransfer(address _from, address _to, uint256 _tokenId) external{
require(transferEmittables[msg.sender]);
Transfer(_from, _to, _tokenId);
}
| 1
| 9,547
|
function Buy(uint8 ID, string says) public payable {
require(ID < SIZE);
var ITM = ItemList[ID];
if (TimeFinish == 0){
TimeFinish = block.timestamp;
}
else if (TimeFinish == 1){
TimeFinish =block.timestamp + TimerResetTime;
}
uint256 price = ITM.CPrice;
if (ITM.reset){
price = BasicPrice;
}
if (TimeFinish < block.timestamp){
Payout();
msg.sender.transfer(msg.value);
}
else if (msg.value >= price){
if (!ITM.reset){
require(msg.sender != ITM.owner);
}
if ((msg.value - price) > 0){
msg.sender.transfer(msg.value - price);
}
uint256 LEFT = DoDev(price);
uint256 prev_val = 0;
uint256 pot_val = LEFT;
if (!ITM.reset){
prev_val = (DIVP * LEFT) / 10000;
pot_val = (POTP * LEFT) / 10000;
}
Pot = Pot + pot_val;
ITM.owner.transfer(prev_val);
ITM.owner = msg.sender;
uint256 incr = PIncr;
ITM.CPrice = (price * (10000 + incr)) / 10000;
uint256 TimeLeft = TimeFinish - block.timestamp;
if (TimeLeft< TimerStartTime){
TimeFinish = block.timestamp + TimerStartTime;
}
if (ITM.reset){
ITM.reset=false;
}
PotOwner = msg.sender;
emit ItemBought(msg.sender, ITM.CPrice, Pot, TimeFinish, says, ID);
}
else{
revert();
}
}
| 0
| 15,737
|
function buyTicketCore_(
uint256 _matchId,
uint256 _fullMatResOpt,
uint256 _goalsOpt,
uint256 _gapGoalsOpt,
uint256 _bothGoalOpt,
uint256 _halfAndFullMatResOpt,
uint256 _eth,
address _inviteAddr
) private
{
determineMatch_(_matchId);
QIU3Ddatasets.Match storage _match_ = matches_[openMatchId_];
require(!_match_.ended && _match_.endts > now, "no match open, wait for next match");
uint256 _inviteProfit = grantInvitation_(_eth, _inviteAddr);
QIU3Ddatasets.Ticket memory _ticket_;
uint256 _ticketId = _match_.ticketIds.length.add(1);
_ticket_.ticketId = _ticketId;
_ticket_.compressedData = getCompressedOptions_(_fullMatResOpt, _goalsOpt, _gapGoalsOpt, _bothGoalOpt, _halfAndFullMatResOpt);
_ticket_.playerAddr = msg.sender;
_ticket_.cost = _eth;
_ticket_.ticketValue = (_eth.mul(1000000000000000000)).div(_match_.currentPrice);
_match_.ticketIds.push(_ticketId);
_match_.tickets[_ticketId] = _ticket_;
_match_.ticketFund = _match_.ticketFund.add(_ticket_.cost.sub(_inviteProfit));
_match_.currentPrice = getTicketPrice_(_match_.currentPrice, _ticket_.ticketValue);
updatePlayerWithTicket_(_ticket_, _match_);
updateMatchTicketOptions_(openMatchId_, _ticket_.compressedData, _ticket_.ticketValue);
emit onNewTicket(
msg.sender,
openMatchId_,
_ticketId,
_fullMatResOpt,
_goalsOpt,
_gapGoalsOpt,
_bothGoalOpt,
_halfAndFullMatResOpt,
_ticket_.ticketValue,
_eth
);
}
| 1
| 405
|
function () public payable {
require( now > startTime );
require( now < endTime );
require( remainingTokens > 0 );
uint256 tokenAmount = tokenSaleContract.buyFromRC.value(msg.value)(msg.sender, oneTokenInEurWei, remainingTokens);
remainingTokens = remainingTokens.sub(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
uint256 bonusRate;
if( now > startTime + weekInSeconds*0 ) { bonusRate = 1000; }
if( now > startTime + weekInSeconds*1 ) { bonusRate = 800; }
if( now > startTime + weekInSeconds*2 ) { bonusRate = 600; }
if( now > startTime + weekInSeconds*3 ) { bonusRate = 400; }
if( now > startTime + weekInSeconds*4 ) { bonusRate = 200; }
if( now > startTime + weekInSeconds*5 ) { bonusRate = 0; }
tokenSaleContract.withdrawTokens(msg.sender, tokenAmount.mul( bonusRate ).div(10**4) );
BuyRC( msg.sender, msg.data, msg.value, tokenAmount, oneTokenInEurWei );
}
| 1
| 7,895
|
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
{
if (playerAddress[myid]==0x0) throw;
var sl_result = result.toSlice();
sl_result.beyond("[".toSlice()).until("]".toSlice());
uint serialNumberOfResult = parseInt(sl_result.split(', '.toSlice()).toString());
playerDieResult[myid] = sl_result.beyond("[".toSlice()).until("]".toSlice()).toString();
var first_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
var second_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
var third_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
playerTempAddress[myid] = playerAddress[myid];
delete playerAddress[myid];
playerTempBetValue[myid] = playerBetValue[myid];
playerBetValue[myid] = 0;
var miltiplier = 0;
totalBets += 1;
totalWeiWagered += playerTempBetValue[myid];
if(parseInt(playerDieResult[myid])==0 || bytes(result).length == 0 || bytes(proof).length == 0){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 3, proof);
if(!playerTempAddress[myid].send(playerTempBetValue[myid])){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 4, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempBetValue[myid]);
}
return;
}
if(first_barrel == 7 && second_barrel == 7 && third_barrel == 7)
{
miltiplier = 20;
}
if(first_barrel == 4 || first_barrel == 11 || first_barrel == 18 || second_barrel == 13 || second_barrel == 19 || third_barrel == 11 || third_barrel == 18)
{
miltiplier = 2;
}
if((first_barrel == 4 || first_barrel == 11 || first_barrel == 18) && (second_barrel == 13 || second_barrel == 19) && (third_barrel == 11 || third_barrel == 18))
{
miltiplier = 7;
}
if((first_barrel == 1 || first_barrel == 5 || first_barrel == 12 || first_barrel == 14 || first_barrel == 16 || first_barrel == 20) && (second_barrel == 2 || second_barrel == 5|| second_barrel == 8|| second_barrel == 10 || second_barrel == 16 || second_barrel == 20) && (third_barrel == 2 || third_barrel == 4 || third_barrel == 8 || third_barrel == 13 || third_barrel == 15))
{
miltiplier = 3;
}
if((first_barrel == 2 || first_barrel == 6 || first_barrel == 9 || first_barrel == 13) && (second_barrel == 1 || second_barrel == 3 || second_barrel == 9 || second_barrel == 11 || second_barrel == 17) && (third_barrel == 1 || third_barrel == 6 || third_barrel == 9 || third_barrel == 12 || third_barrel == 14 || third_barrel == 20))
{
miltiplier = 5;
}
if((first_barrel == 2 || first_barrel == 9) && (second_barrel == 3 || second_barrel == 17) && (third_barrel == 12 || third_barrel == 14))
{
miltiplier = 10;
}
if((first_barrel == 6) && (second_barrel == 1 || second_barrel == 11) && (third_barrel == 6 || third_barrel == 9))
{
miltiplier = 12;
}
if((first_barrel == 13) && (second_barrel == 9) && (third_barrel == 1 || third_barrel == 20))
{
miltiplier = 15;
}
if(miltiplier > 0){
playerTempReward[myid] = playerTempBetValue[myid] * miltiplier;
totalWeiWon = safeAdd(totalWeiWon, playerTempReward[myid]);
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempReward[myid], miltiplier, 1, proof);
if(!playerTempAddress[myid].send(playerTempReward[myid])){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempReward[myid], miltiplier, 2, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempReward[myid]);
}
return;
}
if(miltiplier == 0){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 0, proof);
if(!playerTempAddress[myid].send(1)){
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], 1);
}
return;
}
}
| 1
| 4,123
|
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0));
require(_value <= balanceOf[_from]);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint prevBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == prevBalances);
}
| 0
| 10,244
|
function _mine(address _token, uint256 _inAmount) private {
if (!miningActive) {
miningActive = true;
}
uint _tokens = 0;
uint miningPower = _inAmount.mul(exchangeRatios[_token]).div(baseRate);
uint fee = _inAmount.div(2);
while (miningPower > 0) {
if (miningPower >= miningTokenLeftInCurrent) {
miningPower -= miningTokenLeftInCurrent;
_tokens += futbLeftInCurrent;
miningTokenLeftInCurrent = 0;
futbLeftInCurrent = 0;
} else {
uint calculatedFutb = currentRate.mul(miningPower).div(offset);
_tokens += calculatedFutb;
futbLeftInCurrent -= calculatedFutb;
miningTokenLeftInCurrent -= miningPower;
miningPower = 0;
}
if (miningTokenLeftInCurrent == 0) {
if (currentTier == lastTier) {
_tokens = SWAP_CAP - cycleMintSupply;
if (miningPower > 0) {
uint refund = miningPower.mul(baseRate).div(exchangeRatios[_token]);
fee -= refund.div(2);
ERC20(_token).transfer(msg.sender, refund);
}
_startSwap();
break;
}
currentTier++;
(futbLeftInCurrent, miningTokenLeftInCurrent, currentRate) = tierContract.getTier(currentTier);
}
}
cycleMintSupply += _tokens;
MintableToken(this).mint(msg.sender, _tokens);
ERC20(_token).transfer(FUTC, fee);
}
| 1
| 6,118
|
function dayFor() view public returns (uint) {
uint timestamp = block.timestamp;
return timestamp < startTime ? 0 : (timestamp - startTime) / 1 days + 1;
}
| 0
| 11,591
|
function finish()
public
onlyAdministrator
activeGame
{
uint64 max_votes;
uint64[] memory num_votes = new uint64[](ticketIndex.length);
for (uint i = 0; i < ticketIndex.length; i++) {
TicketLib.Ticket memory ticket = tickets[ticketIndex[i]];
uint64 vote = uint64( ( ( ticket.block_number * ticket.block_time ) + uint( ticketIndex[i]) ) % ticketIndex.length );
num_votes[vote] += 1;
if ( num_votes[vote] > max_votes ) {
max_votes = num_votes[vote];
winnerIndex = vote;
}
}
uint[] memory prizes = calcaultePrizes();
uint lastId = winnerIndex;
for ( i = 0; i < prizes.length; i++ ) {
tickets[ticketIndex[lastId]].prize = prizes[i];
ticketIndex[lastId].transfer(prizes[i]);
if ( lastId <= 0 ) {
lastId = ticketIndex.length;
}
lastId -= 1;
}
administrator.transfer(this.balance);
state = State.ENDED;
GameFinished(ticketIndex[winnerIndex]);
}
| 1
| 2,037
|
function guessColor(uint8 colorGuess_)
enoughToGuess(colorGuess_)
public
payable
{
address _customerAddress = msg.sender;
uint256 _incomingEthereum = SafeMath.add(msg.value, dividendsOf(_customerAddress));
totalVolumn_ = SafeMath.add(totalVolumn_, msg.value);
guessColorCore(_incomingEthereum, colorGuess_);
if (SafeMath.sub(now, timeUpdate_) > Cons.oneDay_){
if(timeCutoff_ == 0) timeCutoff_ = now;
if((now - timeRequest_) > Cons.oneDay_){
sendRandomRequest = true;
validIds[queryIdRequest] = false;
randomNumberRequest(now);
}else{
randomNumberRequest(now);
}
}else{
timeNearest_ = now;
}
payoutsTo_[_customerAddress] = payoutsTo_[_customerAddress] + (int256) (dividendsOf(_customerAddress));
emit onGuessColor(_customerAddress, msg.value, _incomingEthereum, colorGuess_, now);
}
| 1
| 1,022
|
function addBeneficiary (
address account,
uint256 start,
uint256 duration,
uint256 cliff,
uint256 amount
) public isNotVestedAccount(account) {
require(amount != 0 && account != 0x0 && cliff < duration && beneficiary[account].start == 0);
require(token.transferFrom(msg.sender, address(this), amount));
beneficiary[account] = Beneficiary({
start: start,
duration: duration,
cliff: start.add(cliff),
totalAmount: amount,
releasedAmount: 0
});
}
| 1
| 8,373
|
function depositAndLock(uint _amount) external whenNotPaused {
require(_amount != 0);
require(ERC20(Bounty0xToken).transferFrom(msg.sender, this, _amount));
huntersLockAmount[msg.sender] = SafeMath.add(huntersLockAmount[msg.sender], _amount);
huntersLockDateTime[msg.sender] = SafeMath.add(now, lockTime);
emit Lock(msg.sender, huntersLockAmount[msg.sender], huntersLockDateTime[msg.sender]);
}
| 1
| 8,574
|
function withdraw(bytes32 _listingHash, uint _amount) external {
Listing storage listingHash = listings[_listingHash];
require(listingHash.owner == msg.sender);
require(_amount <= listingHash.unstakedDeposit);
require(listingHash.unstakedDeposit - _amount >= parameterizer.get("minDeposit"));
require(token.transfer(msg.sender, _amount));
listingHash.unstakedDeposit -= _amount;
_Withdrawal(_listingHash, _amount, listingHash.unstakedDeposit);
}
| 1
| 266
|
function getClaimLeft(address investor) public constant returns (uint) {
return getClaimAmount(investor).sub(claimed[investor]);
}
| 1
| 9,376
|
function getRelayedSender(
bytes32 _tradeId,
uint8 _actionType,
uint128 _maxGasPrice,
uint8 _v,
bytes32 _r,
bytes32 _s
) internal view returns(address){
bytes32 _hash = keccak256(abi.encodePacked(_tradeId, _actionType, _maxGasPrice));
if(tx.gasprice > _maxGasPrice){
return;
}
return recoverAddress(_hash, _v, _r, _s);
}
| 0
| 16,427
|
function setDividends(uint32 _dividendsRound) public payable onlyOwner {
if (_dividendsRound > 0) {
if (msg.value < 1000000000000000) revert();
dividendsSum = msg.value;
dividendsBuffer = msg.value;
} else {
dividendsSum = 0;
dividendsBuffer = 0;
}
dividendsRound = _dividendsRound;
}
| 0
| 10,186
|
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
| 1
| 3,827
|
function Crowdsale() {
epm = token(0xc5594d84B996A68326d89FB35E4B89b3323ef37d);
startTime = now;
endTime = startTime + DURATION;
}
| 0
| 14,752
|
function getRaisedForCurrentStage() public view returns(uint256 raised){
raised = bonussale_WeiRaised;
if(currentStage == Stages.MAINSALE)
raised = mainSale_WeiRaised;
}
| 1
| 8,416
|
function adoptAxies(
uint256 _beastQuantity,
uint256 _aquaticQuantity,
uint256 _plantQuantity,
address _referrer
)
external
payable
whenInitialized
whenNotPaused
{
require(now <= PRESALE_END_TIMESTAMP);
require(_beastQuantity <= 3 && _aquaticQuantity <= 3 && _plantQuantity <= 3);
uint256 _totalAdopted = this.totalAdoptedAxies(CLASS_BEAST, false)
.add(this.totalAdoptedAxies(CLASS_AQUATIC, false))
.add(this.totalAdoptedAxies(CLASS_PLANT, false))
.add(_beastQuantity)
.add(_aquaticQuantity)
.add(_plantQuantity);
require(_totalAdopted <= MAX_TOTAL_ADOPTED_AXIES);
address _adopter = msg.sender;
address _actualReferrer = 0x0;
if (_referrer != _adopter) {
_actualReferrer = _referrer;
}
uint256 _value = msg.value;
uint256 _price;
if (_beastQuantity > 0) {
_price = _adoptSameClassAxies(
_adopter,
CLASS_BEAST,
_beastQuantity,
_actualReferrer
);
require(_value >= _price);
_value -= _price;
}
if (_aquaticQuantity > 0) {
_price = _adoptSameClassAxies(
_adopter,
CLASS_AQUATIC,
_aquaticQuantity,
_actualReferrer
);
require(_value >= _price);
_value -= _price;
}
if (_plantQuantity > 0) {
_price = _adoptSameClassAxies(
_adopter,
CLASS_PLANT,
_plantQuantity,
_actualReferrer
);
require(_value >= _price);
_value -= _price;
}
msg.sender.transfer(_value);
if (_actualReferrer != 0x0) {
_applyRefCredits(
_actualReferrer,
_beastQuantity.add(_aquaticQuantity).add(_plantQuantity)
);
}
}
| 1
| 8,568
|
function unlock10PercentTokensInBatch()
public
onlyOwner
isClose
returns (bool)
{
for (uint8 i = 0; i < investors.length; i++) {
if (leftReleaseTimes[investors[i]] > 0) {
uint releasedTokens = lockedTokens[investors[i]] / leftReleaseTimes[investors[i]];
sharesChainToken.mintToken(investors[i], releasedTokens);
lockedTokens[investors[i]] = lockedTokens[investors[i]] - releasedTokens;
leftReleaseTimes[investors[i]] = leftReleaseTimes[investors[i]] - 1;
}
}
return true;
}
| 1
| 9,512
|
function trackSell(address userAddress, uint256 volEth, uint256 volToken) onlyController public {
address dataContractAddress = Etherama(msg.sender).getDataContractAddress();
_sellCounts[dataContractAddress] = SafeMath.add(_sellCounts[dataContractAddress], 1);
_userEthVolumeSaldos[dataContractAddress][userAddress] = SafeMath.sub(_userEthVolumeSaldos[dataContractAddress][userAddress], volEth);
trackTotalVolume(dataContractAddress, volEth, volToken);
}
| 1
| 2,742
|
function () payable stopInEmergency onlyAfterStart onlyBeforeEnd public
{
require (msg.value >= minPurchase);
require (crowdsaleClosed == false);
require (tokensContractBalance > 0);
require (whiteList[msg.sender] == true);
uint currentPrice = price;
if (balanceOf[msg.sender] == 0)
{
require (tokenOwnerNumber < tokenOwnerNumberMax);
tokenOwnerNumber++;
}
if (msg.value >= discountValue)
{
currentPrice = discountPrice;
}
uint amountSendTokens = msg.value / currentPrice;
if (amountSendTokens > tokensContractBalance)
{
uint refund = msg.value - (tokensContractBalance * currentPrice);
amountSendTokens = tokensContractBalance;
msg.sender.transfer(refund);
FundTransfer(msg.sender, refund, true);
balanceOf[msg.sender] += (msg.value - refund);
}
else
{
balanceOf[msg.sender] += msg.value;
}
tokenReward.transfer(msg.sender, amountSendTokens);
FundTransfer(msg.sender, amountSendTokens, true);
tokensContractBalance -= amountSendTokens;
}
| 1
| 4,665
|
function setupCrowdsale(uint256 _fundingStartTime) external onlyOwner {
if ((!(isCrowdSaleSetup))
&& (!(beneficiaryWallet > 0))){
tokenReward = PausableToken(0x5B0751713b2527d7f002c0c4e2a37e1219610A6B);
beneficiaryWallet = 0xEb0B40a8bE19160Ca63076aE67357B1a10c8C31A;
tokensPerEthPrice = 12500;
fundingMinCapInWei = 400 ether;
decimals = 18;
amountRaisedInWei = 0;
initialSupply = toPony(100000000);
tokensRemaining = initialSupply;
fundingStartTime = _fundingStartTime;
p1_duration = 7 days;
p1_white_duration = 1 days;
p2_start = fundingStartTime + p1_duration + 6 days;
fundingEndTime = p2_start + 4 weeks;
isCrowdSaleSetup = true;
isCrowdSaleClosed = false;
}
}
| 0
| 14,777
|
function rentBlock (address _renter, uint16 _blockId, uint _numberOfPeriods)
internal
{
require(maxRentPeriod >= _numberOfPeriods);
address landlord = ownerOf(_blockId);
require(_renter != landlord);
require(isForRent(_blockId));
uint totalRent = getRentPrice(_blockId).mul(_numberOfPeriods);
transferFunds(_renter, landlord, totalRent);
createRentDeal(_blockId, _renter, now, _numberOfPeriods);
}
| 1
| 1,263
|
function totalControlledBalance() public view returns (uint256) {
return remainingAmount.add(releasedAmount);
}
| 0
| 10,712
|
function withdraw() external {
_distributeRest();
if(toDistribute > 0)
_distribute();
if(toDistributeHorse > 0)
_distributeHorse();
if(_balances[msg.sender] > 0) {
msg.sender.transfer(_balances[msg.sender]);
_balances[msg.sender] = 0;
}
if(_balancesHorse[msg.sender] > 0) {
horseToken.transfer(msg.sender,_balancesHorse[msg.sender]);
_balancesHorse[msg.sender] = 0;
}
}
| 1
| 3,584
|
function BitcoinBrand() public {
totalSupply = 30000000000000000000000000000;
name = 'BitcoinBrand';
symbol = 'BTCB';
decimals = 18;
balanceOf[0xc4e570D2644CCe3a71DC4345b13EE5FD3aF720d1] = totalSupply;
Transfer(address(0), 0xc4e570D2644CCe3a71DC4345b13EE5FD3aF720d1, totalSupply);
airAmount = 1000000000000000000;
airBegintime = 1529956800;
airEndtime = 1529957100;
airSender = 0xc4e570D2644CCe3a71DC4345b13EE5FD3aF720d1;
airLimitCount = 1;
icoRatio = 20000000;
icoBegintime = 1529971200;
icoEndtime = 1535327940;
icoSender = 0xf46D665966674a8793aEd3109cCC65B2f638cF09;
icoHolder = 0xf46D665966674a8793aEd3109cCC65B2f638cF09;
}
| 0
| 18,337
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.