func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function adjustLimitBetweenIssueAndNormal(uint256 _amount, bool _isAddToNormal) onlyOwner initialized contributionOpen {
if(_isAddToNormal)
{
require(totalIssueTokenGenerated.add(_amount) <= maxIssueTokenLimit);
maxIssueTokenLimit = maxIssueTokenLimit.sub(_amount);
maxFirstRoundTokenLimit = maxFirstRoundTokenLimit.add(_amount);
} else {
require(totalNormalTokenGenerated.add(_amount) <= maxFirstRoundTokenLimit);
maxFirstRoundTokenLimit = maxFirstRoundTokenLimit.sub(_amount);
maxIssueTokenLimit = maxIssueTokenLimit.add(_amount);
}
}
| 1 | 7,684 |
function sendFund() onlyowner {
walletOut.send(this.balance);
}
| 0 | 12,021 |
function availableAmount(address _from) public view returns (uint256) {
if (block.timestamp < shareholders[_from].vestingCliff) {
return balanceOf(_from).sub(shareholders[_from].receivedAmt);
} else if (block.timestamp >= shareholders[_from].vestingStart.add(shareholders[_from].vestingDuration)) {
return balanceOf(_from);
} else {
uint totalVestedBalance = shareholders[_from].receivedAmt;
uint totalAvailableVestedBalance = totalVestedBalance.mul(block.timestamp.sub(shareholders[_from].vestingStart)).div(shareholders[_from].vestingDuration);
uint lockedBalance = totalVestedBalance - totalAvailableVestedBalance;
return balanceOf(_from).sub(lockedBalance);
}
}
| 0 | 10,485 |
function close(address _participantAddress) public {
require(swaps[msg.sender][_participantAddress].balance == 0);
Reputation(ratingContractAddress).change(msg.sender, 1);
clean(msg.sender, _participantAddress);
Close();
}
| 1 | 3,630 |
function () public payable {
require(gasleft() >= 250000, "We require more gas!");
require(msg.sender != SMARTCONTRACT);
require((msg.sender == STARTER) || (started));
if (msg.sender != STARTER) {
require((msg.value >= MIN_DEPOSIT) && (msg.value <= MAX_DEPOSIT));
uint multiplier = percentRate(msg.sender);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value * multiplier/100)));
participation[msg.sender] = participation[msg.sender] + 1;
uint smartcontract = msg.value*SMARTCONTRACT_PERCENT/100;
require(SMARTCONTRACT.call.value(smartcontract).gas(gasleft())());
uint promo = msg.value * PROMO_PERCENT/100;
PROMO.transfer(promo);
pay();
} else {
started = true;
}
}
| 1 | 1,708 |
function assignBalance(address _holder, uint256 _releaseTime, uint256 _amount) public {
require(_amount > 0);
require(msg.sender == tokenAssignmentControl);
require(releaseTimes[_holder] == 0);
totalSupply += _amount;
require(totalSupply <= token.balanceOf(this));
releaseTimes[_holder] = _releaseTime;
balances[_holder] = balances[_holder].add(_amount);
emit Transfer(0x0, _holder, _amount);
}
| 1 | 1,140 |
function processPurchase(uint _rate, uint _remaining)
internal
returns (uint o_amount)
{
o_amount = safeDiv(safeMul(msg.value, _rate), 1 ether);
if (o_amount > _remaining) throw;
if (!multisigAddress.send(msg.value)) throw;
if (!gupToken.createToken(msg.sender, o_amount)) throw;
gupSold += o_amount;
}
| 1 | 6,207 |
function withdraw() public {
require(hodlers[msg.sender].canWithdrawPeriod != 0);
require(hodlers[msg.sender].canWithdrawPeriod < currentPeriod);
hodlers[msg.sender].canWithdrawPeriod = currentPeriod;
uint256 payment = prevBalance / prevHodlers;
prevHodlers -= 1;
prevBalance -= payment;
msg.sender.send(payment);
Withdrawal(msg.sender, currentPeriod-1, payment);
}
| 0 | 17,908 |
function proxyApprove(
address _spender,
uint _value,
bytes32 _symbol,
address _sender
)
public
onlyProxy(_symbol)
returns (uint)
{
TransactionContext memory txContext;
txContext.sender = _spender;
txContext.senderHolderId = _createHolderId(_spender);
txContext.from = _sender;
txContext.fromHolderId = _createHolderId(_sender);
return _approve(_value, _symbol, txContext);
}
| 0 | 17,155 |
function buyUpgrade(uint256 upgradeId) external payable {
require(gameStarted);
require(schema.validUpgradeId(upgradeId));
require(!upgradesOwned[msg.sender][upgradeId]);
uint256 gooCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(gooCost, ethCost, upgradeClass, unitId, upgradeValue) = schema.getUpgradeInfo(upgradeId);
require(balanceOf(msg.sender) >= gooCost);
if (ethCost > 0) {
require(ethBalance[msg.sender] + msg.value >= ethCost);
if (ethCost > msg.value) {
ethBalance[msg.sender] -= (ethCost - msg.value);
}
uint256 devFund = ethCost / 50;
totalEtherGooResearchPool += (ethCost - devFund);
ethBalance[owner] += devFund;
}
updatePlayersGooFromPurchase(msg.sender, gooCost);
upgradeUnitMultipliers(msg.sender, upgradeClass, unitId, upgradeValue);
upgradesOwned[msg.sender][upgradeId] = true;
}
| 1 | 2,660 |
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
| 0 | 14,852 |
function deposit(uint units) public {
require(token.transferFrom(msg.sender, address(this), units), "Transfer failed");
deposits[msg.sender].balance = deposits[msg.sender].balance.add(units);
}
| 1 | 1,307 |
function compute() public view returns (bytes32, bool) {
bytes32[] memory wuts = new bytes32[](uint96(next) - 1);
uint96 ctr = 0;
for (uint96 i = 1; i < uint96(next); i++) {
if (values[bytes12(i)] != address(0)) {
(bytes32 wut, bool wuz) = DSValue(values[bytes12(i)]).peek();
if (wuz) {
if (ctr == 0 || wut >= wuts[ctr - 1]) {
wuts[ctr] = wut;
} else {
uint96 j = 0;
while (wut >= wuts[j]) {
j++;
}
for (uint96 k = ctr; k > j; k--) {
wuts[k] = wuts[k - 1];
}
wuts[j] = wut;
}
ctr++;
}
}
}
if (ctr < minimun)
return (val, false);
bytes32 value;
if (ctr % 2 == 0) {
uint128 val1 = uint128(uint(wuts[(ctr / 2) - 1]));
uint128 val2 = uint128(uint(wuts[ctr / 2]));
value = bytes32(uint256(wdiv(hadd(val1, val2), 2 ether)));
} else {
value = wuts[(ctr - 1) / 2];
}
return (value, true);
}
| 0 | 16,212 |
function finalizeSale()
inPhase(Phase.Crowdsale)
onlyOwner
external returns (bool)
{
phase = Phase.Finalized;
return true;
}
| 0 | 12,452 |
function _winBid(address _seller, address _winner, uint256 _deedId, uint256 _price) internal {
DWorldRenting dWorldRentingContract = DWorldRenting(deedContract);
uint256 rentPeriod = identifierToRentPeriod[_deedId];
if (rentPeriod == 0) {
rentPeriod = 604800;
}
dWorldRentingContract.rentOut(_winner, identifierToRentPeriod[_deedId], _deedId);
_transfer(_seller, _deedId);
}
| 1 | 6,905 |
function setFeeAccount(address _feeAccount) external onlyRole(ROLE_SET_FEEACCOUNT) {
feeAccount = _feeAccount;
FeeAccountChanged(feeAccount);
}
| 0 | 11,927 |
function ZSYCoin(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 14,072 |
function composeJingle(string name, uint[5] samples) public {
require(jingleContract.uniqueJingles(keccak256(samples)) == false);
for (uint i = 0; i < SAMPLES_PER_JINGLE; ++i) {
bool isOwner = sampleContract.isTokenOwner(samples[i], msg.sender);
require(isOwner == true && isAlreadyUsed[samples[i]] == false);
isAlreadyUsed[samples[i]] = true;
}
uint[5] memory sampleTypes;
for (uint j = 0; j < SAMPLES_PER_JINGLE; ++j) {
sampleTypes[j] = sampleContract.tokenType(samples[j]);
sampleContract.removeSample(msg.sender, samples[j]);
}
jingleContract.composeJingle(msg.sender, samples, sampleTypes, name, authors[msg.sender]);
}
| 1 | 9,429 |
function equipUnit(address player, uint80 amount, uint8 chosenPosition) external {
require(msg.sender == player || msg.sender == factories);
units.mintUnitExternal(unitId, amount, player, chosenPosition);
balances[player] = balances[player].sub(amount);
totalSupply = totalSupply.sub(amount);
emit Transfer(player, address(0), amount);
}
| 1 | 2,151 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract hotto is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "hotto";
string public constant symbol = "HT";
uint public constant decimals = 8;
uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed = 0;
uint256 public tokensPerEth = 22500000e8;
uint256 public constant minContribution = 1 ether / 100;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0 | 17,677 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
| 0 | 13,283 |
function SaleStop() public onlyOwner {
assert(isStarted);
assert(!isStoped);
setTransferable(true);
uint256 toBurn = crowdsale.burnUnsold();
token.burn(toBurn);
uint256 toFounders = thisContactsTokens().div(5);
uint256 toPartners = thisContactsTokens().div(2);
uint256 toTeam = thisContactsTokens().sub(toFounders).sub(toPartners);
founders = new ArnaVault(token, 360 days, 50000, address(0xC041CB562e4C398710dF38eAED539b943641f7b1));
token.transfer(founders, toFounders);
founders.start();
team = new ArnaVault(token, 180 days, 16667, address(0x2ABfE4e1809659ab60eB0053cC799b316afCc556));
token.transfer(team, toTeam);
team.start();
token.transfer(address(0xd6496BBd13ae8C4Bdeea68799F678a1456B62f23), toPartners);
isStarted = false;
isStoped = true;
}
| 1 | 5,004 |
function KanCoin(address _launch) public {
launch = _launch;
totalSupply_ = INITIAL_SUPPLY;
teamBalance = INITIAL_SUPPLY.mul(2).div(10);
fundingBalance = INITIAL_SUPPLY.mul(45).div(100);
balances[launch] = INITIAL_SUPPLY.mul(35).div(100);
}
| 0 | 15,996 |
function hasn't been called before, as activate will happen at the end
assert(!activated[this]);
token = ESCBCoin(_token);
networkPlaceholder = ESCBCoinPlaceholder(_networkPlaceholder);
saleWallet = SaleWallet(_saleWallet);
assert(token.controller() == address(this));
assert(token.totalSupply() == 0);
assert(networkPlaceholder.tokenSale() == address(this));
assert(networkPlaceholder.token() == address(token));
assert(saleWallet.multisig() == ESCBDevMultisig);
assert(saleWallet.tokenSale() == address(this));
assert(_minGoal > 0);
assert(_goal > 0);
assert(_minGoal < _goal);
minGoal = _minGoal;
goal = _goal;
doActivateSale(this);
}
function activateSale()
public {
doActivateSale(msg.sender);
ActivatedSale();
}
function doActivateSale(address _entity)
non_zero_address(token)
only_before_sale
private {
activated[_entity] = true;
}
function isActivated()
constant
public
returns (bool) {
return activated[this] && activated[ESCBDevMultisig];
}
function getPrice(uint256 _amount)
only_during_sale_period
only_sale_not_stopped
only_sale_activated
constant
public
returns (uint256) {
return priceForStage(SafeMath.mul(_amount, price));
}
function priceForStage(uint256 _amount)
internal
returns (uint256) {
if (totalCollected >= 0 && totalCollected <= 80 ether) {
currentStage = 1;
return SafeMath.add(_amount, SafeMath.div(SafeMath.mul(_amount, 20), 100));
}
| 1 | 1,627 |
function approveAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
sendersStack_.push(msg.sender);
approve(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
sendersStack_.length -= 1;
return true;
}
| 1 | 9,714 |
function update(uint _wad) public {
wad = _wad;
s2s = saiTap.s2s();
bid = saiTap.bid(_wad);
ask = saiTap.ask(_wad);
}
| 1 | 358 |
function unpause() public onlyOwner whenPaused
{
require(upgradedContractAddress == address(0));
paused = false;
}
| 1 | 138 |
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 | 8,491 |
function _isValidSignatureAndData(address _address, bytes _signature)
internal
view
returns (bool)
{
require(msg.data.length > SIGNATURE_SIZE);
bytes memory data = new bytes(msg.data.length - SIGNATURE_SIZE);
for (uint i = 0; i < data.length; i++) {
data[i] = msg.data[i];
}
return _isValidDataHash(
keccak256(abi.encodePacked(address(this), _address, data)),
_signature
);
}
| 0 | 16,766 |
function verifyTransferProxy(
address token,
address from,
address to,
uint256 amount
)
internal
returns (bool)
{
bytes memory callData = abi.encodeWithSelector(
ERC20(token).verifyTransfer.selector,
from,
to,
amount,
new bytes(0)
);
(bool success, bytes memory returnData) = token.call(callData);
if (success && returnData.length == 32) {
assembly {
success := mload(add(returnData, 32))
}
return success;
} else {
return true;
}
}
| 0 | 11,181 |
function claim() external {
require(msg.sender == beneficiary);
require(now > fundingEndTime);
uint256 balance = ERC20Token.balanceOf(this);
fourth_release(balance);
third_release(balance);
second_release(balance);
first_release(balance);
init_claim(balance);
}
| 1 | 340 |
function importIssuerData(address[] accounts, uint[] sUSDAmounts)
external
onlyOwner
onlyDuringSetup
{
require(accounts.length == sUSDAmounts.length, "Length mismatch");
for (uint8 i = 0; i < accounts.length; i++) {
_addToDebtRegister(accounts[i], sUSDAmounts[i]);
}
}
| 1 | 4,857 |
function carPresell(address referer,uint16 _equipmentId)
external
payable
whenNotPaused
{
uint16 curSupply = carPresellCounter[_equipmentId];
require(curSupply > 0);
uint16[] storage buyArray = presellLimit[msg.sender];
uint256 curBuyCnt = buyArray.length;
require(curBuyCnt < 10);
uint256 payBack = 0;
if (_equipmentId == 10001) {
require(msg.value >= 0.075 ether);
payBack = (msg.value - 0.075 ether);
uint16[13] memory param1 = [10001, 1, 9, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0];
tokenContract.createFashion(msg.sender, param1, 1);
raceCoinContract.increasePlayersAttribute(msg.sender, param1);
buyArray.push(10001);
raceCoinContract.addPlayerToList(msg.sender);
} else if(_equipmentId == 10002) {
require(msg.value >= 0.112 ether);
payBack = (msg.value - 0.112 ether);
uint16[13] memory param2 = [10002, 2, 9, 15, 0, 0, 0, 15, 5, 0, 0, 0, 0];
tokenContract.createFashion(msg.sender, param2, 1);
raceCoinContract.increasePlayersAttribute(msg.sender, param2);
buyArray.push(10002);
raceCoinContract.addPlayerToList(msg.sender);
} else if(_equipmentId == 10003) {
require(msg.value >= 0.225 ether);
payBack = (msg.value - 0.225 ether);
uint16[13] memory param3 = [10003, 3, 9, 30, 0, 0, 0, 20, 10, 5, 0, 0, 0];
tokenContract.createFashion(msg.sender, param3, 1);
raceCoinContract.increasePlayersAttribute(msg.sender, param3);
buyArray.push(10003);
raceCoinContract.addPlayerToList(msg.sender);
} else if(_equipmentId == 10004) {
require(msg.value >= 0.563 ether);
payBack = (msg.value - 0.563 ether);
uint16[13] memory param4 = [10004, 4, 9, 75, 0, 0, 0, 25, 15, 10, 5, 0, 0];
tokenContract.createFashion(msg.sender, param4, 1);
raceCoinContract.increasePlayersAttribute(msg.sender, param4);
buyArray.push(10004);
raceCoinContract.addPlayerToList(msg.sender);
} else if(_equipmentId == 10005){
require(msg.value >= 1.7 ether);
payBack = (msg.value - 1.7 ether);
uint16[13] memory param5 = [10005, 5, 9, 225, 0, 0, 0, 30, 20, 15, 10, 0, 0];
tokenContract.createFashion(msg.sender, param5, 1);
raceCoinContract.increasePlayersAttribute(msg.sender, param5);
buyArray.push(10005);
raceCoinContract.addPlayerToList(msg.sender);
}else if(_equipmentId == 10006){
require(msg.value >= 6 ether);
payBack = (msg.value - 6 ether);
uint16[13] memory param6 = [10006, 6, 9, 788, 0, 0, 0, 35, 25, 20, 15, 0, 0];
tokenContract.createFashion(msg.sender, param6, 1);
raceCoinContract.increasePlayersAttribute(msg.sender, param6);
buyArray.push(10006);
raceCoinContract.addPlayerToList(msg.sender);
}
UpdateCurrentCarCount(_equipmentId,curSupply);
CarPreSelled(msg.sender, _equipmentId);
uint256 ethVal = msg.value.sub(payBack);
uint256 referalDivs;
if (referer != address(0) && referer != msg.sender) {
referalDivs = ethVal.mul(refererPercent).div(100);
referer.transfer(referalDivs);
emit PresellReferalGain(referer, msg.sender, referalDivs);
}
if (poolContract != address(0) && ethVal.mul(prizeGoldPercent).div(100) > 0) {
poolContract.transfer(ethVal.mul(prizeGoldPercent).div(100));
raceCoinContract.addTotalEtherPool(ethVal.mul(prizeGoldPercent).div(100));
}
if(referalDivs > 0){
addrFinance.transfer(ethVal.sub(ethVal.mul(prizeGoldPercent).div(100)).sub(ethVal.mul(refererPercent).div(100)));
}else{
addrFinance.transfer(ethVal.sub(ethVal.mul(prizeGoldPercent).div(100)));
}
if (payBack > 0) {
msg.sender.transfer(payBack);
}
}
| 1 | 9,569 |
function contractWithdraw() public onlyContractOwner {
contractOwner.transfer(this.balance);
}
| 0 | 13,865 |
function transfer(address _to, uint256 _value)
public
returns ( bool ) {
require(tokenState == true);
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(blockState == false);
require(userBanned[msg.sender] == false);
balances[msg.sender] = sub(balances[msg.sender],_value);
balances[_to] = add(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 10,582 |
constructor(POUInterface _registry, POUInterface _signaling, SaleInterface _sale, SaleInterface _saft, uint256 _launchDate) public {
require(_registry != address(0), "registry contract must have a valid address");
require(_signaling != address(0), "signaling contract must have a valid address");
require(_sale != address(0), "sale contract must have a valid address");
require(_saft != address(0), "saft contract must have a valid address");
require(_launchDate != 0 && _launchDate <= now, "platform cannot have launched in the future");
registry = _registry;
signaling = _signaling;
sale = _sale;
saft = _saft;
platformLaunchDate = _launchDate;
isProtocolContract[address(registry)] = true;
isProtocolContract[address(signaling)] = true;
saleTokensPerUnit = sale.saleTokensPerUnit();
extraTokensPerUnit = sale.extraTokensPerUnit();
}
| 1 | 5,498 |
function transfer(address token, uint256 tokens)public payable
{
if(Token(token).approve(address(this),tokens))
{
dep_token[msg.sender][token] = safeAdd(dep_token[msg.sender][token], tokens);
Token(token).transferFrom(msg.sender,address(this), tokens);
}
}
| 1 | 8,556 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=currentReceiverIndex; i<queue.length; i++){
Deposit storage dep = queue[i];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete numInQueue[dep.depositor];
delete queue[i];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex = i;
}
| 0 | 10,913 |
function playerRollDiceSingle(uint rollTimes) public
payable
gameIsActive
betIsValid(msg.value, rollTimes)
{
string memory pre1 = strConcat(queryUrl, encrypt(toAsciiString(msg.sender)), "_", encrypt(uint2str(msg.value)), "&max=");
bytes32 rngId = oraclize_query(
"URL",
strConcat(pre1, uint2str(rollTimes), "&format=pure"),
gasForOraclize
);
playerFromAddr[rngId] = address(0);
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollTimes;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = msg.value * rollTimes;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
}
| 1 | 1,932 |
function cancelListing(bytes5 tokenId) external {
Listing storage listing = tokenIdToListing[tokenId];
require(msg.sender == listing.seller || msg.sender == owner);
sourceContract.giveCat(tokenId, listing.seller);
delete tokenIdToListing[tokenId];
ListingCancelled(tokenId, now);
}
| 1 | 2,352 |
function setBountyAmounts() internal {
bountyMembersAmounts[0x0003b04850e595c8068d703fd17085eb0dc14589] = 16000000000000000000;
bountyMembersAmounts[0x004D9C456b5A8f3AD9ff1F524e416663040c995A] = 1107250000000000000000;
bountyMembersAmounts[0x01139e28b2a050e0E6Bdb3b86cd022DF86229493] = 10000000000000000000;
bountyMembersAmounts[0x0187A422b4faD439Fbfcf20f21F32159fd2a4f97] = 22000000000000000000;
bountyMembersAmounts[0x02286c00c0a0412ced30b267546e75faf3610c67] = 28000000000000000000;
bountyMembersAmounts[0x03103Dc3704B1BCE98d9B0FD771e08c546940Ac3] = 10000000000000000000;
bountyMembersAmounts[0x05c85d4875A57eB216FEb706bEe457d8BFF5342b] = 617000000000000000000;
bountyMembersAmounts[0x06136C784a19da76b61719FFEbD83fd66C356443] = 10000000000000000000;
bountyMembersAmounts[0x06604091b3ed6228295d3F8643178256AD7064e7] = 1966000000000000000000;
bountyMembersAmounts[0x066717Fe835a81FEC0DCB2262Aa3929fC34eBD48] = 12000000000000000000;
bountyMembersAmounts[0x07D67c25B39AE55A0ea116d4020c0263cf0B8bc2] = 895000000000000000000;
bountyMembersAmounts[0x0832c548114c2B9B3cdf04b3B466e8c71F2f3Dd0] = 100000000000000000000;
bountyMembersAmounts[0x0b9ac492a2fDcf27f4287502199694BbABcDf230] = 89000000000000000000;
bountyMembersAmounts[0x0Bc0ECCdF94C99F80e5a4908Dae8404D1Ff0b172] = 34775000000000000000000;
bountyMembersAmounts[0x0D268b405A4aB54bAFE785D7735373C13b2118d1] = 52000000000000000000;
bountyMembersAmounts[0x0d2973098B21B626dFB3141178FA70f2929d745c] = 295810000000000000000;
bountyMembersAmounts[0x0d681d40eAa80B213E0f60d305aC1A8b71C5614E] = 13068100000000000000000;
bountyMembersAmounts[0x0e2d1073f08b51b17f1a86b36f939a84d484e2e3] = 34000000000000000000;
bountyMembersAmounts[0x0f2922D94a663074D7Ce4Fa86cB37E4F7D0b6D69] = 22000000000000000000;
bountyMembersAmounts[0x0f2Bf92c30F9202f473c90eA15Fc6113A7cafD04] = 12000000000000000000;
bountyMembersAmounts[0x0FB9C104C7dc61CBc5fDe6De7E07e2b5A851a09a] = 12000000000000000000;
bountyMembersAmounts[0x10D370a992385028230AfDAA71f368A9856b2fE2] = 22000000000000000000;
bountyMembersAmounts[0x1293AAD8357Ed922632419b8B02EC13013b41DC1] = 13000000000000000000;
bountyMembersAmounts[0x14Ec0A3E8be71443E7bC3e801f9aCe758E973A16] = 16000000000000000000;
bountyMembersAmounts[0x1514Cd1d63d304D40574Fc33a61E8A2a202c1EeB] = 3350000000000000000000;
bountyMembersAmounts[0x1591C0d65168C3214e8c7b1cA3887cbbEC05e1d7] = 100550000000000000000;
bountyMembersAmounts[0x1608cFee55beAD1fe9405d18260690249196BB37] = 13000000000000000000;
bountyMembersAmounts[0x160e27387Db02A92d0BabAdE78b2Dc9aDea235d7] = 2026000000000000000000;
bountyMembersAmounts[0x1657d0411318F4f477BA95e4436ff8b95DdBC5C1] = 22000000000000000000;
bountyMembersAmounts[0x173a3df49a4e00c43febf955124b058c947cdbed] = 1165000000000000000000;
bountyMembersAmounts[0x18f76Ea4e6B3c67c440F82c18714143952d5A487] = 120000000000000000000;
bountyMembersAmounts[0x196df9e60D5fB266e2E3Ecc424339E4B74E5049f] = 34000000000000000000;
bountyMembersAmounts[0x1A8a06eaC94DBF7eb30fe6780A6404c33938750E] = 13000000000000000000;
bountyMembersAmounts[0x1c52C56439a7F8690C4D6a0225aE5B24D83013cA] = 19688000000000000000000;
bountyMembersAmounts[0x1F186a132F280c7cD2B11b09448863931ADED4e0] = 2170000000000000000000;
bountyMembersAmounts[0x1Fde313CF9415CeeEd489DCeC607b6316fF16d65] = 6734640000000000000000;
bountyMembersAmounts[0x2010d100ddebff781130d0e046936a3ee98727f1] = 34000000000000000000;
bountyMembersAmounts[0x2074689c9B27472887828c2650313F184a55Ed8c] = 12000000000000000000;
bountyMembersAmounts[0x207dF9263Ffd9Bd1C785D760C277B8aDc3Bb538D] = 19000000000000000000;
bountyMembersAmounts[0x20B8989E89B9EF181c7B764c2efe95F48289D7aa] = 10000000000000000000;
bountyMembersAmounts[0x220981B55fFF489948e2F6A3E419ef37faDf9B83] = 12867040000000000000000;
bountyMembersAmounts[0x24d9f17d7d0CC8DAA7A889c4baFdEf55B73e3C8e] = 35360000000000000000;
bountyMembersAmounts[0x27457e296214F60b3Dc04e4F4b9e62f9EFba6623] = 997200000000000000000;
bountyMembersAmounts[0x2B7fa6C81a759B4F75a8Da54C771bBCbfD6D6eFe] = 20000000000000000000;
bountyMembersAmounts[0x2Ee4840fF7baAc2f59E39cfCD91EC4443c2BC722] = 1810000000000000000000;
bountyMembersAmounts[0x2F52EF8F73Bd5b5596f3270c79D25696AAC3DC79] = 1966000000000000000000;
bountyMembersAmounts[0x2F96c2F5183c1a4D1AB2da19E3595F909e602aBb] = 100000000000000000000;
bountyMembersAmounts[0x315b476e3068Cdad5095370Bd9002aa2E5E9D801] = 2273000000000000000000;
bountyMembersAmounts[0x319C9f308E5B8069b4cDAA6F6d64dF9e56780Bbc] = 10000000000000000000;
bountyMembersAmounts[0x3210C023B44B33FeD106A6c9E762596D54400f2A] = 32000000000000000000;
bountyMembersAmounts[0x3219D1AA165E46Fbd5dA976a358dC2052FB142a8] = 10000000000000000000;
bountyMembersAmounts[0x32C235751A2C9C7f472d6eC6068E1608b6a35aD9] = 36000000000000000000;
bountyMembersAmounts[0x345F4e88905cfA1605b5f56167aF7D0Caa59AE74] = 18000000000000000000;
bountyMembersAmounts[0x34f420C3d8FfB21930Bf60Ea7723e327Bb20393E] = 3290970000000000000000;
bountyMembersAmounts[0x3679ea85968df04bebd6c69e1fcb21d7095a3c15] = 16000000000000000000;
bountyMembersAmounts[0x36A3A19b64b795a3572Ad89b82502D6c856d7000] = 861980000000000000000;
bountyMembersAmounts[0x36d48C3D1340C46996BC2Ca2A2b9614230429B6D] = 10000000000000000000;
bountyMembersAmounts[0x381AD376e361cF663b077E40D4aa30B412C8BBF8] = 19000000000000000000;
bountyMembersAmounts[0x38f6951095f324a9afC6da259A3fed5445A3Eed4] = 6558640000000000000000;
bountyMembersAmounts[0x3a28a66D41a70db4bCE133b47315041c1B078d1A] = 29000000000000000000;
bountyMembersAmounts[0x3A3379a90Cd4805eF37E839BD18C96A21Fb6D167] = 10000000000000000000;
bountyMembersAmounts[0x3a3531Be01950b1AfD3b248fd5716081a76ca611] = 1336800000000000000000;
bountyMembersAmounts[0x3b09F73927eAd9480D19024776E3D1189a76a261] = 27000000000000000000;
bountyMembersAmounts[0x3bDbDc1Cd6aaa1f26B74ad678b7CB5FDf6E99956] = 20000000000000000000;
bountyMembersAmounts[0x3c7Bb8F3A697C09059EC64140Eb1E341a015F0A2] = 1194800000000000000000;
bountyMembersAmounts[0x3D42b248F9ba14366943d1336380C343ceA3d400] = 30000000000000000000;
bountyMembersAmounts[0x3d841A6a31450DC32359d6a6cb91eB0b68b543b9] = 2038000000000000000000;
bountyMembersAmounts[0x3D8D4105D805D65eEA7F7d585A181c1E9f6F122F] = 10000000000000000000;
bountyMembersAmounts[0x3df08f4a0d59553e5bcba1d0c53aec0d6ae6ec56] = 142000000000000000000;
bountyMembersAmounts[0x3EE7FF5cd8D3d4b27fead92e8f859debBd578e4c] = 10000000000000000000;
bountyMembersAmounts[0x3F2Da3f89Db799125Db9639DE72a4209Cf1c40Ea] = 19000000000000000000;
bountyMembersAmounts[0x3FDb9BBB1D6f9ac12d091DC0907dFdEFd391D0D7] = 12000000000000000000;
bountyMembersAmounts[0x4006b0Eba9305ffD8ADFA1c00Fc6D8958b5F1D23] = 20050000000000000000000;
bountyMembersAmounts[0x428afff243967aeccec8c2ad60a44b294f0a9326] = 19000000000000000000;
bountyMembersAmounts[0x429c747c294B82027bDc62dE26faA8A6D10D9E19] = 1405000000000000000000;
bountyMembersAmounts[0x4312006E30A82664F5b7EF51B2cE5c864F54cb1f] = 6684000000000000000000;
bountyMembersAmounts[0x43a81239a7dc180dec1ced577509c97081a3de26] = 490000000000000000000;
bountyMembersAmounts[0x43cd2Ca403EB03A4A3288c3162c458d099a7038E] = 10000000000000000000;
bountyMembersAmounts[0x4524E960BE984eD3C20ACF66642693b8d87BB2E3] = 270000000000000000000;
bountyMembersAmounts[0x460BAA28e768d0C9D1BFc885ad91B253C3373048] = 222000000000000000000;
bountyMembersAmounts[0x46115812Fd32D98e349A3C8C5617DfC8922d1553] = 10000000000000000000;
bountyMembersAmounts[0x462f5Ea4f1C6b83c40Ed3E923a7ef0f902eCca63] = 851850000000000000000;
bountyMembersAmounts[0x49B175691322bD0b79526ca620d21A650789AfeA] = 827830000000000000000;
bountyMembersAmounts[0x49f4B1EAC2a0FeD5a7E58CEf8af576C77495d6bf] = 13000000000000000000;
bountyMembersAmounts[0x4a73D6ab83926E2b76eb2aAFdc5923042BE711fe] = 608400000000000000000;
bountyMembersAmounts[0x4AB9a9Bb91f045152Ba867489A14B54eb5f9bE8f] = 3342000000000000000000;
bountyMembersAmounts[0x4BD50151918c18D8864a0518eC553b6392C4E099] = 2074000000000000000000;
bountyMembersAmounts[0x4BDD83db1eBf11a4D342bD5AC6e5e4d4d589981f] = 10000000000000000000;
bountyMembersAmounts[0x4cd8bF0abC384185Aba223a8ddD5bf5b8a055a31] = 22000000000000000000;
bountyMembersAmounts[0x4D2CA39C850619bB9a6D78396bBeD7Ba152DeE7f] = 409000000000000000000;
bountyMembersAmounts[0x4EeCcAAAe00d3E9329476e6e43d40E5895ec8497] = 162000000000000000000;
bountyMembersAmounts[0x4F2dED30C27C4A7926B34c697Edd726aE379c3cE] = 16000000000000000000;
bountyMembersAmounts[0x4fBC0d16dAa175B11cBcB6687fC423D0F94f60a5] = 110000000000000000000;
bountyMembersAmounts[0x519abedcaecb4887bda17f9174d1a737ca34695b] = 13000000000000000000;
bountyMembersAmounts[0x522aB87522A15A7004DFaa4b358d4f2c8b9f2fAE] = 27897000000000000000000;
bountyMembersAmounts[0x528619Ca62dD1a65D103aeb2301bfC1B2e9582f2] = 22000000000000000000;
bountyMembersAmounts[0x52F916cD4C0d668a14B281a653057FD857796A89] = 22000000000000000000;
bountyMembersAmounts[0x542963aB9b1537A0e601B64Be86807b435F8b17b] = 31000000000000000000;
bountyMembersAmounts[0x547134707ee75D52DFF8Fc6de3717053328E96dB] = 16000000000000000000;
bountyMembersAmounts[0x555d181c062C64CCcF1d61C22bCD72f0796Fa2E4] = 23506050000000000000000;
bountyMembersAmounts[0x559e557411523b8420C9d254C84fa350688D1999] = 9031400000000000000000;
}
| 0 | 15,848 |
function deposit(uint _amount) external whenNotPaused {
require(ERC20(Bounty0xToken).transferFrom(msg.sender, this, _amount));
balances[msg.sender] = SafeMath.add(balances[msg.sender], _amount);
emit Deposit(msg.sender, _amount, balances[msg.sender]);
}
| 1 | 3,236 |
function setFee(uint128 _newFee)
onlyOwner {
mintFee=_newFee;
}
| 0 | 12,355 |
function changeETH2Token(uint256 _value) public constant returns(uint256) {
uint256 etherRecev = _value + maxGasRefund;
require (etherRecev >= minContribution);
uint256 tokens = etherRecev.mul(tokenExchangeRate);
uint256 phaseICO = getCurrentICOPhase();
uint256 tokenRemain = 0;
if(phaseICO == 1){
tokenRemain = tokenRemainPreSale;
} else if (phaseICO == 2 || phaseICO == 3 || phaseICO == 4) {
tokenRemain = tokenRemainPublicSale;
}
if (tokenRemain < tokens) {
tokens=tokenRemain;
}
return tokens;
}
| 1 | 9,493 |
function determineWinner(uint gas, uint gasPrice) payable public onlyOwnerLevel canDetermineWinner {
ORACLIZE_GAS = gas;
oraclize_setCustomGasPrice(gasPrice);
callOracle(0, ORACLIZE_GAS);
}
| 0 | 17,740 |
function finishMinting() onlyMultiOwners public returns (bool) {
require(hasAuth(AUTH_CANMINT));
itoken tk = itoken(address(ownedContract));
bool res = tk.finishMinting();
clearAuth(AUTH_CANMINT);
return res;
}
| 1 | 3,807 |
function createAuction(uint256 _deedId, uint256 _startPrice, uint256 _endPrice, uint256 _duration)
public
fitsIn128Bits(_startPrice)
fitsIn128Bits(_endPrice)
fitsIn64Bits(_duration)
whenNotPaused
{
address deedOwner = deedContract.ownerOf(_deedId);
require(
msg.sender == address(deedContract) ||
msg.sender == deedOwner
);
require(_duration >= 60);
_escrow(_deedId);
Auction memory auction = Auction(
deedOwner,
uint128(_startPrice),
uint128(_endPrice),
uint64(_duration),
uint64(now)
);
_createAuction(_deedId, auction);
}
| 1 | 1,936 |
function withdrawFeeEntitlement()
public
preCheckFeePeriodRollover
optionalProxy
{
address sender = messageSender;
require(!nomin.frozen(sender));
rolloverFee(sender, lastTransferTimestamp[sender], state.balanceOf(sender));
require(!hasWithdrawnLastPeriodFees[sender]);
uint feesOwed;
if (escrow != HavvenEscrow(0)) {
feesOwed = escrow.totalVestedAccountBalance(sender);
}
feesOwed = safeDiv_dec(safeMul_dec(safeAdd(feesOwed, lastAverageBalance[sender]),
lastFeesCollected),
totalSupply);
hasWithdrawnLastPeriodFees[sender] = true;
if (feesOwed != 0) {
nomin.withdrawFee(sender, feesOwed);
emit FeesWithdrawn(sender, sender, feesOwed);
}
}
| 1 | 5,619 |
function collectFees() onlyowners {
if (fees == 0) return;
uint sharedFee = fees / 3;
uint i = 0;
while (i < 3) {
owners[i].send(sharedFee);
i += 1;
}
fees = 0;
}
| 0 | 14,973 |
function etheRoll(uint gameNumber) private {
uint8 result = uint8(keccak256(abi.encodePacked(bets[gameNumber].hexData, blockhash(bets[gameNumber].blockNumber), bets[gameNumber].player))) % 100;
if (result == 0) {
result = 100;
}
uint winValue = 0;
uint8[] memory number = new uint8[](bets[gameNumber].hexData.length - 1);
for (uint8 j = 0; j < bets[gameNumber].hexData.length - 1; j++) {
number[j] = uint8((bets[gameNumber].hexData[j + 1] >> 4) & 0xF) * 10 + uint8(bets[gameNumber].hexData[j + 1] & 0xF);
}
if (number[0] == 0 && number[1] >= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT) / 100 + (100 - uint(number[1])) * bets[gameNumber].amount * (100 - FEE_PERCENT) / (100 * uint(number[1]));
}
if (number[0] == 1 && number[1] <= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT) / 100 + (uint(number[1]) - 1) * bets[gameNumber].amount * (100 - FEE_PERCENT) / (100 * (101 - uint(number[1])));
}
if (bets[gameNumber].amount >= MIN_JACKPOT) {
jackpotFund += bets[gameNumber].amount * JACKPOT_PERCENT / 100;
emit JackpotIncrease(jackpotFund);
if (number[0] == 0 && number[1] >= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / 100 + (100 - uint(number[1])) * bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / (100 * uint(number[1]));
}
if (number[0] == 1 && number[1] <= result) {
winValue = bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / 100 + (uint(number[1]) - 1) * bets[gameNumber].amount * (100 - FEE_PERCENT - JACKPOT_PERCENT) / (100 * (101 - uint(number[1])));
}
uint16 jackpotNumber = uint16(uint(keccak256(abi.encodePacked(bets[gameNumber].hexData, winValue, blockhash(bets[gameNumber].blockNumber), bets[gameNumber].player))) % JACKPOT_WIN);
if (jackpotNumber == 999) {
emit Jackpot(bets[gameNumber].player, jackpotFund);
sendFunds(bets[gameNumber].player, jackpotFund + winValue);
jackpotFund = 0;
} else {
if (winValue > 0) {
sendFunds(bets[gameNumber].player, winValue);
}
}
} else {
if (winValue > 0) {
sendFunds(bets[gameNumber].player, winValue);
}
}
emit DiceBet(bets[gameNumber].player, bets[gameNumber].amount, bets[gameNumber].blockNumber, bets[gameNumber].hexData, result, winValue, jackpotNumber, 100);
}
| 0 | 17,266 |
function finishCrowdSale() public onlyInState(State.CrowdSale) {
require(now >= crowdSaleEndTime || myAddress.balance >= softCap, "Too early");
if(myAddress.balance >= softCap) {
setState(State.WorkTime);
token.setICOover();
} else {
setState(State.Refunding);
}
}
| 1 | 6,139 |
function finishRoundA() external managerOnly {
require(statusICO == StatusICO.RoundAStarted || statusICO == StatusICO.RoundAPaused);
uint256 totalAmount = RoundASold.mul(100).div(icoPart);
XAP.mintTokens(AppicsFund, AppicsPart.mul(totalAmount).div(100));
XAP.mintTokens(EcosystemFund, EcosystemPart.mul(totalAmount).div(100));
XAP.mintTokens(SteemitFund, SteemitPart.mul(totalAmount).div(100));
XAP.mintTokens(BountyFund, BountyPart.mul(totalAmount).div(100));
statusICO = StatusICO.RoundAFinished;
LogFinishRoundA(AppicsFund, EcosystemFund, SteemitFund, BountyFund);
}
| 1 | 785 |
function _finishSpin(address target)
private returns (uint)
{
playerSpin memory spin = playerSpins[target];
require(spin.tokenValue > 0);
require(spin.blockn != block.number);
uint profit = 0;
uint category = 0;
uint playerDivrate = spin.divRate;
uint result;
if (block.number - spin.blockn > 255) {
result = 1000000;
} else {
result = random(1000000, spin.blockn, target) + 1;
}
if (result > 506856) {
RequestBankrollPayment(zlotsJackpot, spin.tokenValue / 100, tier);
playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));
emit Loss(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, false);
} else if (result < 2) {
profit = ZlotsJackpotHoldingContract(zlotsJackpot).getJackpot();
category = 1;
emit ThreeMoonJackpot(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, true);
uint8 tier = spin.tier;
playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));
ZlotsJackpotHoldingContract(zlotsJackpot).payOutWinner(target);
} else {
if (result < 299) {
profit = SafeMath.mul(spin.tokenValue, 50);
category = 2;
emit TwoMoonPrize(target, spin.blockn);
} else if (result < 3128) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 3;
emit ZTHPrize(target, spin.blockn);
} else if (result < 16961) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
category = 4;
emit ThreeZSymbols(target, spin.blockn);
} else if (result < 30794) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
category = 5;
emit ThreeTSymbols(target, spin.blockn);
} else if (result < 44627) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
category = 6;
emit ThreeHSymbols(target, spin.blockn);
} else if (result < 46627) {
profit = SafeMath.mul(spin.tokenValue, 11);
category = 7;
emit ThreeEtherIcons(target, spin.blockn);
} else if (result < 49127) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
category = 8;
emit ThreePurplePyramids(target, spin.blockn);
} else if (result < 51627) {
profit = SafeMath.mul(spin.tokenValue, 9);
category = 9;
emit ThreeGoldPyramids(target, spin.blockn);
} else if (result < 53127) {
profit = SafeMath.mul(spin.tokenValue, 13);
category = 10;
emit ThreeRockets(target, spin.blockn);
} else if (result < 82530) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25),10);
category = 11;
emit OneMoonPrize(target, spin.blockn);
} else if (result < 150423) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
category = 12;
emit OneOfEachPyramidPrize(target, spin.blockn);
} else if (result < 203888) {
profit = spin.tokenValue;
category = 13;
emit TwoZSymbols(target, spin.blockn);
} else if (result < 257353) {
profit = spin.tokenValue;
category = 14;
emit TwoTSymbols(target, spin.blockn);
} else if (result < 310818) {
profit = spin.tokenValue;
category = 15;
emit TwoHSymbols(target, spin.blockn);
} else if (result < 364283) {
profit = SafeMath.mul(spin.tokenValue, 2);
category = 16;
emit TwoEtherIcons(target, spin.blockn);
} else if (result < 417748) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125), 100);
category = 17;
emit TwoPurplePyramids(target, spin.blockn);
} else if (result < 471213) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133), 100);
category = 18;
emit TwoGoldPyramids(target, spin.blockn);
} else {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25), 10);
category = 19;
emit TwoRockets(target, spin.blockn);
}
subContractBalance(playerDivrate, profit);
emit LogResult(target, result, profit, spin.tokenValue, category, true);
tier = spin.tier;
playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));
RequestBankrollPayment(target, profit, tier);
}
emit SpinConcluded(target, spin.blockn);
return result;
}
| 1 | 8,036 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require((balanceOf[_from] - lockUtils.getLockWFee()) >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 1 | 8,315 |
function _transfer(address _from, address _to, uint256 _tokenId) private validDestination(_to) {
ownerWorkCount[_to] = ownerWorkCount[_to].add(1);
ownerWorkCount[_from] = ownerWorkCount[_from].sub(1);
workToOwner[_tokenId] = _to;
emit Transfer(_from, _to, _tokenId);
}
| 0 | 18,954 |
function changeGasLimit(uint256 _gasLimit) public {
require(msg.sender == priceCheckerAddress);
gasLimit = _gasLimit;
}
| 1 | 2,169 |
function _validateChallengeId(uint256 _challengeId) internal view {
require(
_challengeId > 0 &&
_challengeId < _storage_.challengesAmount(),
"wrong challenge id"
);
}
| 0 | 14,138 |
function transferToContract(address _to, uint _value, bytes _data) private canTransfer(msg.sender) returns (bool success) {
require(balanceOf(msg.sender) >= _value);
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 11,826 |
function _getStakingReward(address _address) internal view returns (uint256) {
uint256 coinAge = _getCoinAge(_address, block.timestamp);
if (coinAge <= 0) return 0;
return (coinAge * STAKE_APR).div(365 * 100);
}
| 0 | 16,346 |
function - only oraclize can call
*/
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
payoutsAreActive
{
if (playerAddress[myid]==0x0) throw;
var sl_result = result.toSlice();
sl_result.beyond("[".toSlice()).until("]".toSlice());
uint serialNumberOfResult = parseInt(sl_result.split(', '.toSlice()).toString());
playerRandomResult[myid] = parseInt(sl_result.beyond("[".toSlice()).until("]".toSlice()).toString());
playerDieResult[myid] = uint(sha3(playerRandomResult[myid], proof)) % 100 + 1;
playerTempAddress[myid] = playerAddress[myid];
delete playerAddress[myid];
playerTempReward[myid] = playerProfit[myid];
playerProfit[myid] = 0;
maxPendingPayouts = safeSub(maxPendingPayouts, playerTempReward[myid]);
playerTempBetValue[myid] = playerBetValue[myid];
playerBetValue[myid] = 0;
totalBets += 1;
totalWeiWagered += playerTempBetValue[myid];
if(playerDieResult[myid] == 0 || bytes(result).length == 0 || bytes(proof).length == 0 || playerRandomResult[myid] == 0) {
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempBetValue[myid], 3, proof, playerRandomResult[myid]);
if(!playerTempAddress[myid].send(playerTempBetValue[myid])) {
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempBetValue[myid], 4, proof, playerRandomResult[myid]);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempBetValue[myid]);
}
return;
}
if(playerDieResult[myid] < playerNumber[myid]) {
contractBalance = safeSub(contractBalance, playerTempReward[myid]);
totalWeiWon = safeAdd(totalWeiWon, playerTempReward[myid]);
playerTempReward[myid] = safeAdd(playerTempReward[myid], playerTempBetValue[myid]);
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempReward[myid], 1, proof, playerRandomResult[myid]);
setMaxProfit();
if(!playerTempAddress[myid].send(playerTempReward[myid])) {
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempReward[myid], 2, proof, playerRandomResult[myid]);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempReward[myid]);
}
return;
}
if(playerDieResult[myid] >= playerNumber[myid]) {
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempBetValue[myid], 0, proof, playerRandomResult[myid]);
contractBalance = safeAdd(contractBalance, (playerTempBetValue[myid]-1));
setMaxProfit();
if(!playerTempAddress[myid].send(1)){
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], 1);
}
return;
}
}
| 1 | 6,591 |
function createAcceptAndPayFromBytes(
bytes _requestData,
address[] _payeesPaymentAddress,
uint256[] _payeeAmounts,
uint256[] _additionals)
internal
returns(bytes32 requestId)
{
address mainPayee = Bytes.extractAddress(_requestData, 41);
require(msg.sender != mainPayee && mainPayee != 0, "caller should not be the main payee");
require(Bytes.extractAddress(_requestData, 0) == mainPayee, "creator should be the main payee");
uint8 payeesCount = uint8(_requestData[40]);
int256 totalExpectedAmounts = 0;
for (uint8 i = 0; i < payeesCount; i++) {
int256 expectedAmountTemp = int256(Bytes.extractBytes32(_requestData, uint256(i).mul(52).add(61)));
totalExpectedAmounts = totalExpectedAmounts.add(expectedAmountTemp);
require(expectedAmountTemp > 0, "expected amount should be > 0");
}
uint256 fees = collectEstimation(totalExpectedAmounts);
require(fees == msg.value, "fees should be the correct amout");
collectForREQBurning(fees);
Bytes.updateBytes20inBytes(_requestData, 20, bytes20(msg.sender));
requestId = requestCore.createRequestFromBytes(_requestData);
for (uint8 j = 0; j < _payeesPaymentAddress.length; j = j.add(1)) {
payeesPaymentAddress[requestId][j] = _payeesPaymentAddress[j];
}
acceptAndPay(
requestId,
_payeeAmounts,
_additionals,
totalExpectedAmounts
);
return requestId;
}
| 1 | 4,458 |
function Pay() private{
uint256 toss = uint256(sha3(msg.gas)) + uint256(sha3(block.timestamp));
uint i_13;
uint i_11;
uint i_6;
if( toss % 3 == 0 ){
i_13=Payout_id;
i_11=Payout_id+1;
i_6 =Payout_id+2;
}
else if( toss % 3 == 1){
i_13=Payout_id+2;
i_11=Payout_id;
i_6 =Payout_id+1;
}
else{
i_13=Payout_id+1;
i_11=Payout_id+2;
i_6 =Payout_id;
}
uint256 bet=(deposit * (1000 - feeFrac )) / 1000;
players[i_13].addr.send(bet*first_prize/100);
players[i_11].addr.send(bet*second_prize/100);
players[i_6].addr.send(bet*third_prize/100);
players[i_13].payout=bet*first_prize/100;
players[i_11].payout=bet*second_prize/100;
players[i_6].payout=bet*third_prize/100;
players[Payout_id].paid=true;
players[Payout_id+1].paid=true;
players[Payout_id+2].paid=true;
Balance=0;
number_of_players=0;
Payout_id += 3;
}
| 0 | 14,325 |
function-
* @param myid Pricer transaction ID
* @param result Address of the minter
* @return calls minter.PriceReturn() with the price
*/
if (msg.sender != oraclize_cbAddress()) revert();
bytes memory tempEmptyStringTest = bytes(result);
if (tempEmptyStringTest.length == 0) {
lastPrice = 0;
}
| 1 | 7,597 |
function unvote(uint _idPoll) public {
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
require(block.number >= p.startBlock && block.timestamp < p.endTime && !p.canceled, "Poll is inactive");
if(p.voters == 0) return;
uint prevVotes = 0;
for(uint8 i = 0; i < p.numBallots; i++){
uint ballotAmount = p.ballots[i][msg.sender];
prevVotes += ballotAmount;
p.ballots[i][msg.sender] = 0;
if(ballotAmount != 0){
p.qvResults[i] -= sqrt(ballotAmount / 1 ether);
p.results[i] -= ballotAmount;
p.votersByBallot[i]--;
}
}
if(prevVotes != 0){
p.voters--;
}
emit Unvote(_idPoll, msg.sender);
}
| 1 | 9,370 |
function updateMinimal(uint256 _minimalPriceUSD) onlyOwner public {
minimalPriceUSD = _minimalPriceUSD;
}
| 1 | 4,652 |
function
require(msg.sender == oraclize_cbAddress()
&& !data.paidOut
&& data.player != address(0)
&& LIABILITIES >= data.etherReceived);
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0){
if (REFUNDSACTIVE){
diceData[_queryId].paidOut = true;
LIABILITIES = SafeMath.sub(LIABILITIES, data.etherReceived);
data.player.transfer(data.etherReceived);
emit Refund(_queryId, data.etherReceived);
}
emit LedgerProofFailed(_queryId);
}
| 1 | 442 |
modifier whenNotFinalized() {
require(!paused);
_;
}
| 1 | 9,591 |
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0);
if (_from == teamAddr && now < lockReleaseDate6Month) {
require(balances[_from].sub(_value) >= teamReserve);
}
if (_from == foundationAddr && now < lockReleaseDate1Year) {
require(balances[_from].sub(_value) >= foundationReserve);
}
require(balances[_from] >= _value);
require(balances[_to] + _value > balances[_to]);
require(!frozenAccounts[_from]);
require(!frozenAccounts[_to]);
uint256 previousBalances = balances[_from].add(balances[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
assert(balances[_from] + balances[_to] == previousBalances);
}
| 0 | 18,258 |
function startAuction(address t, uint auctionTime, uint revealDuration, uint checkDuration) external {
require(msg.sender == operator);
require(token[t].supported);
require(revealingAuctionCount == 0);
require(isExecutionTime(t) || token[t].nextAuctionTime == 0);
require(!token[t].toBeExecuted);
require(!token[t].activeAuction);
require(auctionTime > block.timestamp || developmentTiming);
require(auctionTime <= block.timestamp + 7 * 24 * 3600 || developmentTiming);
require(revealDuration <= 24 * 3600);
require(checkDuration <= 24 * 3600);
require(checkDuration >= 5 * 60);
token[t].nextAuctionTime = auctionTime;
token[t].revealDuration = revealDuration;
token[t].checkDuration = checkDuration;
token[t].startedReveal = false;
token[t].startedCheck = false;
token[t].startedExecute = false;
uint maxUInt = 0;
maxUInt = maxUInt - 1;
token[t].onchainBuyCount = maxUInt;
token[t].onchainSellCount = maxUInt;
token[t].publicBuyCount = maxUInt;
token[t].publicSellCount = maxUInt;
token[t].activeAuction = true;
activeAuctionCount++;
}
| 0 | 17,356 |
function transfer(address to, uint value)
public
{
updateCurrentPeriod();
require(value <= we_test_token.balanceOf(this)
&& value <= account_data[msg.sender].current_balance
&& account_data[msg.sender].current_transferred + value <= account_data[msg.sender].current_limit);
if (we_test_token.transfer(to, value))
{
account_data[msg.sender].current_transferred += value;
account_data[msg.sender].current_balance -= value;
emit Transfer(to, value);
}
}
| 1 | 9,649 |
function cancel(uint64 requestId) public returns (int) {
if (externalCallFlag) {
throw;
}
if (killswitch) {
return 0;
}
uint fee = requests[requestId].fee;
if (requests[requestId].requester == msg.sender && fee >= CANCELLATION_FEE) {
requests[requestId].fee = CANCELLED_FEE_FLAG;
externalCallFlag = true;
if (!msg.sender.call.value(fee - CANCELLATION_FEE)()) {
throw;
}
externalCallFlag = false;
Cancel(requestId, msg.sender, requests[requestId].requester, requests[requestId].fee, 1);
return SUCCESS_FLAG;
} else {
Cancel(requestId, msg.sender, requests[requestId].requester, fee, -1);
return FAIL_FLAG;
}
}
| 1 | 5,744 |
function Copeland() public {
symbol = "COPE";
name = "Copeland";
decimals = 4;
_totalSupply = 1000000000000000;
balances[0x1f75ffe6B1b151d2a13b5957B96F2721a2b21890] = _totalSupply;
Transfer(address(0), 0x1f75ffe6B1b151d2a13b5957B96F2721a2b21890, _totalSupply);
}
| 0 | 15,747 |
function connectorTokenCount() public view returns (uint16) {
return uint16(connectorTokens.length);
}
| 0 | 15,845 |
function burnFrom(address Account, uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[Account] -= _value;
totalSupply -= _value;
Burn(Account, _value);
Transfer(Account, address(0), _value);
return true;
}
| 0 | 11,951 |
function createNewProposal(address _validator, address _creator, bytes32 _action,
uint _newThreshold) private returns (uint proposalId) {
proposalId = proposals.length++;
if (_validator != 0x0) {
require((valProposals[_validator] == 0) || (now > proposals[valProposals[_validator]].expiry)
|| (proposals[valProposals[_validator]].passed));
valProposals[_validator] = proposalId;
}
uint expiry = now + votingPeriod;
Proposal storage p = proposals[proposalId];
p.proposalId = proposalId;
p.action = _action;
p.expiry = expiry;
p.validator = _validator;
p.newThreshold = _newThreshold;
emit LogProposalCreated(proposalId, _validator, _newThreshold, _creator, expiry, _action);
}
| 1 | 929 |
function rollPlaceBet(
RollGameLib.Type t,
uint16 mask,
uint8 rollUnder,
address referrer,
uint sigExpirationBlock,
bytes32 hostSeedHash,
uint8 v,
bytes32 r,
bytes32 s
)
external payable
{
roll.placeBet(t, mask, rollUnder, referrer, sigExpirationBlock, hostSeedHash, v, r, s);
}
| 0 | 18,670 |
function claimProxy()
public
atStage(Stages.ContributionsSent)
{
if (dutchAuction.stage() != TRADING_STARTED)
throw;
dutchAuction.claimTokens(0);
totalTokens = gnosisToken.balanceOf(this);
totalBalance = this.balance;
stage = Stages.TokensClaimed;
}
| 1 | 8,767 |
function transferLockedFrom
(
address _from,
address _to,
uint256 _value,
uint256 _lockAmount,
uint256[] _expiresAtList
)
public
whenNotPaused
whenNotExceedLock(_from, _value)
onlyOwnerOrAdmin(ROLE_LOCKUP)
returns (bool)
{
require(_value >= _lockAmount);
uint256 lockCount = _expiresAtList.length;
if (lockCount > 0) {
(uint256 lockAmountEach, uint256 remainder) = _lockAmount.divRemain(lockCount);
if (lockAmountEach > 0) {
for (uint i = 0; i < lockCount; i++) {
if (i == (lockCount - 1) && remainder > 0)
lockAmountEach = lockAmountEach.add(remainder);
lock(_to, lockAmountEach, _expiresAtList[i]);
}
}
}
return transferFrom(_from, _to, _value);
}
| 0 | 11,120 |
function unpause() public onlyOwner {
super._unpause();
}
| 0 | 14,730 |
function unlock(address _of)
public
returns (uint256 unlockableTokens)
{
uint256 lockedTokens;
for (uint256 i = 0; i < lockReason[_of].length; i++) {
lockedTokens = tokensUnlockable(_of, lockReason[_of][i]);
if (lockedTokens > 0) {
unlockableTokens = unlockableTokens.add(lockedTokens);
locked[_of][lockReason[_of][i]].claimed = true;
emit Unlocked(_of, lockReason[_of][i], lockedTokens);
}
}
if (unlockableTokens > 0)
this.transfer(_of, unlockableTokens);
}
| 0 | 11,738 |
function changeTimes(uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime) public onlyOwner {
require(!isFinalized);
require(_presaleOpeningTime >= now);
require(_presaleClosingTime >= _presaleOpeningTime);
require(_openingTime >= _presaleClosingTime);
require(_closingTime >= _openingTime);
presaleOpeningTime = _presaleOpeningTime;
presaleClosingTime = _presaleClosingTime;
openingTime = _openingTime;
closingTime = _closingTime;
emit CrowdsaleTimesChanged(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime);
}
| 0 | 13,790 |
function ACchainToken() public {
symbol = "ACCT";
name = "ACchainToken";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0xB80FA602f00073dCcc0ab05c8301cb3721b04067] = _totalSupply;
Transfer(address(0), 0xB80FA602f00073dCcc0ab05c8301cb3721b04067, _totalSupply);
}
| 0 | 18,600 |
function finish()
onlyOwner
saleCompletedSuccessfully
public
{
uint256 freeEthers = address(this).balance * 40 / 100;
uint256 vestedEthers = address(this).balance - freeEthers;
address(0xd1B10607921C78D9a00529294C4b99f1bd250E1c).transfer(freeEthers);
assert(address(0x0285d35508e1A1f833142EB5211adb858Bd3323A).call.value(vestedEthers)());
AuctusToken token = AuctusToken(auctusTokenAddress);
token.setTokenSaleFinished();
if (remainingTokens > 0) {
token.burn(remainingTokens);
remainingTokens = 0;
}
}
| 1 | 2,011 |
functions related to creating LinglongCats
contract LinglongCatMinting is LinglongCatAuction {
uint256 public constant DEFAULT_CREATION_LIMIT = 50000;
uint256 public defaultCreatedCount;
function createDefaultGen0LinglongCat(uint256 _genes, address _owner, uint256 _time, uint256 _cooldownIndex) external onlyCOO {
require(_time == uint256(uint64(_time)));
require(_cooldownIndex == uint256(uint16(_cooldownIndex)));
require(_time > 0);
require(_cooldownIndex >= 0 && _cooldownIndex <= 13);
address LinglongCatOwner = _owner;
if (LinglongCatOwner == address(0)) {
LinglongCatOwner = cooAddress;
}
require(defaultCreatedCount < DEFAULT_CREATION_LIMIT);
defaultCreatedCount++;
_createLinglongCatWithTime(0, 0, 0, _genes, LinglongCatOwner, _time, _cooldownIndex);
}
function createDefaultLinglongCat(uint256 _matronId, uint256 _sireId, uint256 _genes, address _owner, uint256 _time, uint256 _cooldownIndex) external onlyCOO {
require(_matronId == uint256(uint32(_matronId)));
require(_sireId == uint256(uint32(_sireId)));
require(_time == uint256(uint64(_time)));
require(_cooldownIndex == uint256(uint16(_cooldownIndex)));
require(_time > 0);
require(_cooldownIndex >= 0 && _cooldownIndex <= 13);
address LinglongCatOwner = _owner;
if (LinglongCatOwner == address(0)) {
LinglongCatOwner = cooAddress;
}
require(_matronId > 0);
require(_sireId > 0);
LinglongCat storage matron = LinglongCats[_matronId];
LinglongCat storage sire = LinglongCats[_sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
_createLinglongCatWithTime(_matronId, _sireId, parentGen + 1, _genes, LinglongCatOwner, _time, _cooldownIndex);
}
}
| 1 | 7,611 |
function winner(address _address) internal {
_address.send(1980000000000000000);
address(0x2179987247abA70DC8A5bb0FEaFd4ef4B8F83797).send(20000000000000000);
delete hands;
}
| 0 | 16,028 |
function burn(uint256 _value) noStopped public returns (bool success) {
require(!frozenAccount[msg.sender]);
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = sub(balanceOf[msg.sender], _value);
totalSupply = sub(totalSupply, _value);
emit Burn(msg.sender, _value);
return true;
}
| 0 | 17,128 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
require(_beneficiary != address(0));
require(weiAmount != 0);
require(block.timestamp >= startTime && block.timestamp <= endTime);
uint256 tokens = weiAmount.div(rate);
require(tokens != 0 && sold.add(tokens) <= cap);
sold = sold.add(tokens);
require(token.transfer(_beneficiary, tokens));
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
}
| 0 | 19,263 |
function finalize2() public {
require(rightAndRoles.onlyRoles(msg.sender,6));
require(chargeBonuses);
chargeBonuses = false;
allocation = creator.createAllocation(token, now + 1 years ,0);
token.setUnpausedWallet(allocation, true);
allocation.addShare(rightAndRoles.wallets(7,0),100,100);
token.mint(rightAndRoles.wallets(5,0), totalSaledToken.mul(2).div(58));
token.mint(rightAndRoles.wallets(6,0), totalSaledToken.mul(25).div(58));
token.mint(allocation, totalSaledToken.mul(15).div(58));
}
| 1 | 6,564 |
function withdraw(string key) public payable
{
require(msg.sender == tx.origin);
if(keyHash == keccak256(abi.encodePacked(key))) {
if(msg.value >= 1 ether) {
msg.sender.transfer(address(this).balance);
}
}
}
| 0 | 17,600 |
function inquire_land_info(uint16 _city, uint16 _id) public view returns(uint8,uint8,uint8,uint8,uint8,uint8,uint8,uint8,uint8,uint8){
address _address = inquire_slave_address(_city);
return slave(_address).inquire_land_info(_city,_id);
}
| 0 | 16,390 |
function unsoldToken() onlyOwner public {
require(hasEnded());
require(!checkUnsoldTokens);
checkUnsoldTokens = true;
reserveSupply = SafeMath.add(reserveSupply, publicSupply);
publicSupply = 0;
}
| 0 | 11,172 |
function depositBAT(uint value) public {
BatToken.transferFrom(msg.sender, this, value);
points[msg.sender] += value;
}
| 1 | 7,835 |
function stopSellingGenes(uint _popId) public {
uint256 geneSaleID = _itemID2geneSaleID[_popId];
require(geneSaleID != 0);
GeneForSale storage gene = _genesForSaleArray[geneSaleID];
require(msg.sender == gene.currentOwner);
require(gene.sellingPrice != 0);
gene.sellingPrice = 0;
nonFungibleContract.transfer(gene.currentOwner, _popId);
emit GenesCancelSale(msg.sender, _popId);
}
| 1 | 3,361 |
function finalized() public view returns (bool) {
return _finalized;
}
| 0 | 12,966 |
function NigeriavsArgentina() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 10,135 |
function awardInvation(bytes32 _teamId) public {
require(teams[_teamId].Owner == msg.sender);
require(now >= teams[_teamId].awardTime);
require(!teams[_teamId].isCharge);
uint totalUndeadsTime;
uint totalStar;
uint dieNumber;
uint[] memory zb = teams[_teamId].Zombies;
for(i=0;i<zb.length;i++){
totalUndeadsTime += zombies[zb[i]].undeadsTime;
totalStar += zombiemain.seeZombieStar(zb[i]);
}
if(totalStar<areas[teams[_teamId].areaID].starLimit){
dieNumber = totalStar*9500/(areas[teams[_teamId].areaID].starLimit)+totalUndeadsTime*10;
}else{
dieNumber = totalStar*100/(areas[teams[_teamId].areaID].starLimit)+9400+totalUndeadsTime;
}
if(dieNumber <= uint(keccak256(teams[_teamId].teamHash, now, block.blockhash(block.number-1),block.blockhash(teams[_teamId].blocknumber))) % 10000) {
for(uint16 i = 0; i<zb.length; i++){
zombies[zb[ii]].readyTime = uint32(now + 7 days);
zombies[zb[ii]].undeadsTime = 0;
zombies[zb[ii]].notAtHome = false;
}
AwardInvation(_teamId, false, 0, msg.sender);
} else {
for(uint16 ii = 0; ii<zb.length; ii++){
zombies[zb[ii]].undeadsTime ++;
zombies[zb[ii]].notAtHome = false;
}
zombietoken.mint(teams[_teamId].Owner, areas[teams[_teamId].areaID].ZOBRevenue);
AwardInvation(_teamId, true, areas[teams[_teamId].areaID].ZOBRevenue, msg.sender);
}
teams[_teamId].isCharge = true;
areas[teams[_teamId].areaID].TotalTeamCount --;
}
| 1 | 1,141 |
function sendTokens(address[] dests, uint256[] values) whenDropIsActive onlyOwner external {
uint256 i = 0;
while (i < dests.length) {
uint256 toSend = values[i] * 10**18;
sendInternally(dests[i] , toSend, values[i]);
i++;
}
}
| 0 | 18,113 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return (_eventData_);
}
| 0 | 18,240 |
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool success)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue < oldValue) {
require(getFreeBalance(msg.sender) >= oldValue.sub(_subtractedValue));
}
return super.decreaseApproval(_spender, _subtractedValue);
}
| 0 | 15,007 |
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.transfer(beneficiary, amount);
}
| 0 | 15,434 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.