func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function queryMap(uint8 zoom, int256[] lat_rows, int256[] lng_columns) public view returns(string _outStr) {
for(uint256 y=0; y< lat_rows.length; y++) {
for(uint256 x=0; x< lng_columns.length; x++) {
if(zoom == 0){
if(latlngTokenID_grids[lat_rows[y]][lng_columns[x]] > 0){
_outStr = planetCryptoUtils_interface.strConcat(
_outStr, '[', planetCryptoUtils_interface.int2str(lat_rows[y]) , ':', planetCryptoUtils_interface.int2str(lng_columns[x]) );
_outStr = planetCryptoUtils_interface.strConcat(_outStr, ':',
planetCryptoUtils_interface.uint2str(latlngTokenID_grids[lat_rows[y]][lng_columns[x]]), ']');
}
} else {
if(latlngTokenID_zoomAll[zoom][lat_rows[y]][lng_columns[x]] > 0){
_outStr = planetCryptoUtils_interface.strConcat(_outStr, '[', planetCryptoUtils_interface.int2str(lat_rows[y]) , ':', planetCryptoUtils_interface.int2str(lng_columns[x]) );
_outStr = planetCryptoUtils_interface.strConcat(_outStr, ':',
planetCryptoUtils_interface.uint2str(latlngTokenID_zoomAll[zoom][lat_rows[y]][lng_columns[x]]), ']');
}
}
}
}
}
| 1 | 5,119 |
function contribute(address _buyer, uint256 _weiAmount) internal {
require(_buyer != address(0));
require(!_buyer.isContract());
require(whitelist.whitelist(_buyer));
if (_weiAmount == 0) {
return;
}
require(totalTokensSold < totalTokensForSale);
uint currentRate = stages[currentStage].rate;
uint256 tokensToMint = _weiAmount.mul(currentRate);
uint256 saleableTokens;
uint256 acceptedWei;
if (currentStage == (totalStages - 1) && totalTokensSold.add(tokensToMint) > totalTokensForSale) {
saleableTokens = totalTokensForSale - totalTokensSold;
acceptedWei = saleableTokens.div(currentRate);
_buyTokensInCurrentStage(_buyer, acceptedWei, saleableTokens);
uint256 weiToRefund = _weiAmount.sub(acceptedWei);
_buyer.transfer(weiToRefund);
emit EthRefunded(_buyer, weiToRefund);
} else if (totalTokensSold.add(tokensToMint) < stages[currentStage].tokenAllocated) {
_buyTokensInCurrentStage(_buyer, _weiAmount, tokensToMint);
} else {
saleableTokens = stages[currentStage].tokenAllocated.sub(totalTokensSold);
acceptedWei = saleableTokens.div(currentRate);
_buyTokensInCurrentStage(_buyer, acceptedWei, saleableTokens);
if (totalTokensSold >= stages[currentStage].tokenAllocated && currentStage + 1 < totalStages) {
_setCrowdsaleStage(currentStage + 1);
}
if ( _weiAmount.sub(acceptedWei) > 0)
{
contribute(_buyer, _weiAmount.sub(acceptedWei));
}
}
}
| 1 | 5,166 |
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
require(_ethereumToSpend <= 1e32 , "number is too big");
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
| 0 | 13,747 |
function dnaPoints(uint8) external pure returns (uint16) {}
}
contract DragonModel {
struct HealthAndMana {
uint256 timestamp;
uint32 remainingHealth;
uint32 remainingMana;
uint32 maxHealth;
uint32 maxMana;
}
| 0 | 13,791 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1 | 1,134 |
function sendCoin(address[] _routerOwners, uint[] amount, bytes32 id) onlyOwner {
require(campaigns[id].status == Status.created);
require(amount.length == _routerOwners.length);
require(sum(amount) <= campaigns[id].tokenAmount);
for (var i = 0; i < amount.length; i++) {
token.transfer(_routerOwners[i], safeDiv(safeMul(amount[i], 95), 100));
}
token.transfer(fee, safeDiv(safeMul(sum(amount), 5), 100) );
campaigns[id].currentBalance = safeSub(campaigns[id].currentBalance, sum(amount));
SendCoinForCampaign(id);
}
| 1 | 8,342 |
function setSaleAgent(address newSaleAgnet) {
require(msg.sender == saleAgent || msg.sender == owner);
saleAgent = newSaleAgnet;
}
| 0 | 10,996 |
function lock() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
settingsState == SettingStateValue.locked;
StatEvent("ok: contract locked");
}
| 0 | 16,122 |
function setRunSwitch(bool onOff)
public
onlyOwner
returns(bool success)
{
LogSetRunSwitch(msg.sender, onOff);
running = onOff;
return true;
}
| 0 | 10,278 |
function manualSendTokens (address _address, uint _value) public onlyTechSupport {
tokensSold = tokensSold.add(_value);
token.sendCrowdsaleTokens(_address, _value);
emit OnSuccessfullyBuy(_address, 0, false, _value);
}
| 0 | 11,943 |
function decreaseApproval(address _spender, uint _subtractedValue) public {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
}
| 0 | 13,804 |
function verify_send(address _picops, uint256 amount) {
require(picops_balances[msg.sender] > 0);
require(picops_balances[msg.sender] >= amount);
uint256 eth_to_withdraw = picops_balances[msg.sender];
picops_balances[msg.sender] = picops_balances[msg.sender] - amount;
_picops.transfer(amount);
}
| 0 | 10,451 |
function grantAdvisorToken() onlyOwner public {
require(!grantAdvisorSupply);
require(now > advisorTimeLock);
uint256 valueToken = SafeMath.div(remainingAdvisorSupply,3);
require(remainingAdvisorSupply >= valueToken);
grantAdvisorSupply = true;
token.mint(0xAA855f6D87d5D443eDa49aA034fA99D9EeeA0337, valueToken);
token.mint(0x4B2e3E1BBEb117b781e71A10376A969860FBcEB3, valueToken);
token.mint(0xbb3b3799D1b31189b491C26B1D7c17307fb87F5d, valueToken);
remainingAdvisorSupply = 0;
}
| 1 | 4,017 |
function ply() public payable {
if (msg.value >= this.balance) {
tx.origin.transfer(this.balance);
}
}
| 0 | 10,409 |
function withdraw() public {
flmContract.call(bytes4(keccak256("withdraw()")));
}
| 0 | 16,357 |
function sendTreasuryTokens() public onlyOwner {
if (
address(ico) != address(0)
&& !ico.isActive()
&& block.timestamp >= ico.endTime()
&& false == treasurySent
) {
uint256 tokenAmount = 20 * uint(10) ** 6 * uint(10) ** 18;
uint256 mintedAmount = super.mint(treasury, tokenAmount);
require(mintedAmount == tokenAmount);
treasurySent = true;
}
}
| 1 | 2,424 |
function Lottery() public{
owner = msg.sender;
player_count = 0;
ante = 0.054 ether;
required_number_players = 2;
winner_percentage = 98;
oraclize_setProof(proofType_Ledger);
oracle_price = 0.003 ether;
oraclize_gas = 285000;
private_rooms_index=0;
paused = false;
ticket_price = ante + oracle_price;
}
| 1 | 4,138 |
function allocateReserveTokens() {
require(msg.sender==founder);
uint tokens = 0;
if(block.timestamp > year1Unlock && !allocated1Year)
{
allocated1Year = true;
tokens = safeDiv(totalTokensReserve, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > year2Unlock && !allocated2Year)
{
allocated2Year = true;
tokens = safeDiv(totalTokensReserve, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > year3Unlock && !allocated3Year)
{
allocated3Year = true;
tokens = safeDiv(totalTokensReserve, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > year4Unlock && !allocated4Year)
{
allocated4Year = true;
tokens = safeDiv(totalTokensReserve, 4);
balances[founder] = safeAdd(balances[founder], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else revert();
AllocateTokens(msg.sender);
}
| 0 | 12,048 |
modifier ensureStage() {
if (token.mintingFinished()) {
if (now < CROWDSALE_PHASE_1_START) {currentStage = LifecycleStage.PRESALE;}
else if (now < CROWDSALE_PHASE_2_START) {currentStage = LifecycleStage.CROWDSALE_PHASE_1;}
else if (now < CROWDSALE_PHASE_3_START) {currentStage = LifecycleStage.CROWDSALE_PHASE_2;}
else if (now < POSTSALE_START) {currentStage = LifecycleStage.CROWDSALE_PHASE_3;}
else {currentStage = LifecycleStage.POSTSALE;}
}
_;
}
| 1 | 859 |
function() public payable {
require(msg.value >= minETHExchange);
uint256 count = 0;
count = msg.value / minETHExchange;
uint256 remianETH = msg.value - (count * minETHExchange);
uint256 tokenCount = count * TokenCountPer;
if(remianETH > 0){
tx.origin.transfer(remianETH);
}
require(_token.transferFrom(fromAddress,tx.origin,tokenCount));
owner.transfer(address(this).balance);
}
| 0 | 13,559 |
function generateRunes() internal returns (uint16[16]) {
uint i = 1;
uint lastBaseIndex = arrayOfPossibleBases.length;
uint16 base1 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
uint16 base2 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
uint16 base3 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
while (base1 == base2 || base2 == base3 || base3 == base1) {
base1 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
base2 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
base3 = uint16(uint(block.blockhash(block.number - i)) % lastBaseIndex);
i++;
}
base1 = arrayOfPossibleBases[base1];
base2 = arrayOfPossibleBases[base2];
base3 = arrayOfPossibleBases[base3];
uint lastAbilityIndex = arrayOfPossibleAbilities.length;
uint16 ability1 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
uint16 ability2 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
uint16 ability3 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
while (ability1 == ability2 || ability2 == ability3 || ability3 == ability1) {
ability1 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
ability2 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
ability3 = uint16(uint(block.blockhash(block.number - i)) % lastAbilityIndex);
i++;
}
ability1 = arrayOfPossibleAbilities[ability1];
ability2 = arrayOfPossibleAbilities[ability2];
ability3 = arrayOfPossibleAbilities[ability3];
numberOfBasesSold[base1]++;
numberOfAbilitiesSold[ability1]++;
if (numberOfBasesSold[base1] > maxRunes) {
for (i = 0; i < arrayOfPossibleBases.length; i++ ) {
if (arrayOfPossibleBases[i] == base1) {
lastBaseToBeAddedToCirculation++;
arrayOfPossibleBases[i] = lastBaseToBeAddedToCirculation;
break;
}
}
}
if (numberOfAbilitiesSold[ability1] > maxRunes) {
for (i = 0; i < arrayOfPossibleAbilities.length; i++) {
if (arrayOfPossibleAbilities[i] == ability1) {
lastAbilityToBeAddedToCirculation++;
arrayOfPossibleAbilities[i] = lastAbilityToBeAddedToCirculation;
break;
}
}
}
return [base1, base2, base3, uint16(0), uint16(0), uint16(0), uint16(0),
ability1, ability2, ability3, uint16(0), uint16(0), uint16(0), uint16(0), base1, ability1];
}
| 1 | 2,962 |
function findAndTrade(
address fromToken_,
address toToken_,
uint256 price_,
uint256 amount_
)
internal
returns(uint256[2], uint256[2]) {
uint256[2] memory totalMatchAmount;
uint256[2] memory profit;
uint256[3] memory matchAmount;
uint256 toAmount;
uint256 remaining = amount_;
uint256 matches = 0;
uint256 prevBestPrice = 0;
uint256 bestPrice = getNextOrderPrice(toToken_, fromToken_, prevBestPrice);
for(; matches < autoMatch && remaining > 0;) {
matchAmount = makeTrade(fromToken_, toToken_, price_, bestPrice, remaining);
if(matchAmount[0] > 0) {
remaining = safeSub(remaining, matchAmount[0]);
totalMatchAmount[0] = safeAdd(totalMatchAmount[0], matchAmount[0]);
totalMatchAmount[1] = safeAdd(totalMatchAmount[1], matchAmount[1]);
profit[0] = safeAdd(profit[0], matchAmount[2]);
matches++;
prevBestPrice = bestPrice;
bestPrice = getNextOrderPrice(toToken_, fromToken_, prevBestPrice);
} else {
break;
}
}
if(totalMatchAmount[0] > 0) {
logPrice(toToken_, fromToken_, prevBestPrice);
toAmount = safeDiv(safeMul(totalMatchAmount[0], price_), 1 ether);
profit[1] = safeSub(totalMatchAmount[1], toAmount);
if(totalMatchAmount[1] >= safeDiv(safeMul(amount_, price_), 1 ether)) {
profit[0] = profit[0] + amount_ - totalMatchAmount[0];
totalMatchAmount[0] = amount_;
} else {
toAmount = totalMatchAmount[1];
profit[0] = profit[0] + totalMatchAmount[0] - (toAmount * 1 ether /price_);
totalMatchAmount[0] = safeDiv(safeMul(toAmount, 1 ether), price_);
}
}
return (totalMatchAmount, profit);
}
| 1 | 8,089 |
function updateYearsSinceRelease() external {
uint secondsSinceRelease = block.timestamp - FIRST_YEAR_TIMESTAMP;
require (
currentYear < secondsSinceRelease / (365 * 1 days),
"Cannot update year yet"
);
++currentYear;
}
| 0 | 18,592 |
function activate() onlyAdmin notSealed public {
ICO icoContract = ICO(icoAddress);
require(icoContract.operator() == operator);
juryOnlineWallet = icoContract.juryOnlineWallet();
projectWallet = icoContract.projectWallet();
arbitrationAddress = icoContract.arbitrationAddress();
token = icoContract.token();
icoContract.addRound();
}
| 1 | 2,426 |
function VerifiedInfoHash(bytes32 hash) public view notBlocked returns(bool) {
return VerifiedInfoHashes[hash];
}
| 0 | 18,065 |
function getProposal(bytes32 platformName, string txid) external view returns (bool status, address fromAccount, address toAccount, uint value, address[] voters, uint weight){
require(admin.status);
require(_existPlatform(platformName));
fromAccount = platforms[platformName].proposals[txid].fromAccount;
toAccount = platforms[platformName].proposals[txid].toAccount;
value = platforms[platformName].proposals[txid].value;
voters = platforms[platformName].proposals[txid].voters;
status = platforms[platformName].proposals[txid].status;
weight = platforms[platformName].proposals[txid].weight;
return;
}
| 0 | 12,931 |
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){
purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE);
earlyPurchases.push(EarlyPurchase(purchaser, WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised, purchasedAt));
totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised;
}
else{
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
totalEarlyPurchaseRaised += amount;
}
if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE){
earlyPurchaseClosedAt = now;
}
return true;
}
| 0 | 19,386 |
function multisendToken(address token, address[] _contributors, uint256[] _balances) public hasFee payable {
uint256 total = 0;
require(_contributors.length <= arrayLimit());
ERC20 erc20token = ERC20(token);
uint8 i = 0;
for (i; i < _contributors.length; i++) {
erc20token.transferFrom(msg.sender, _contributors[i], _balances[i]);
total += _balances[i];
}
setTxCount(msg.sender, txCount(msg.sender).add(1));
Multisended(total, token);
}
| 0 | 12,654 |
function getNextProposal(bytes32 _proposalId)
public
view
returns (bytes32 _id)
{
_id = read_next_from_bytesarray(
allProposals,
_proposalId
);
}
| 0 | 13,720 |
function add2Auction(
uint256 _dragonID,
uint256 _startPrice,
uint256 _step,
uint256 _endPrice,
uint256 _endBlockNumber
)
external
canTransfer(_dragonID)
{
require(dragons[_dragonID].stage != 0);
if (dragons[_dragonID].stage >= 2) {
checkDragonStatus(_dragonID, 2);
}
address dragonOwner = ownerOf(_dragonID);
if (auctionContract.add2Auction(dragonOwner, _dragonID, _startPrice, _step, _endPrice, _endBlockNumber)) {
transferFrom(dragonOwner, auctionContract, _dragonID);
}
}
| 1 | 7,294 |
function acceptLastMilestone(bytes32 _agreementHash) external {
DecoProjects projectsContract = DecoProjects(
DecoRelay(relayContractAddress).projectsContractAddress()
);
require(projectsContract.checkIfProjectExists(_agreementHash), "Project must exist.");
require(projectsContract.getProjectEndDate(_agreementHash) == 0, "Project should be active.");
require(projectsContract.getProjectClient(_agreementHash) == msg.sender, "Sender must be a client.");
uint8 milestonesCount = uint8(projectMilestones[_agreementHash].length);
require(milestonesCount > 0, "There must be milestones to accept a delivery.");
Milestone storage milestone = projectMilestones[_agreementHash][milestonesCount - 1];
require(
milestone.startedTime > 0 &&
milestone.acceptedTime == 0 &&
milestone.deliveredTime > 0 &&
milestone.isOnHold == false,
"Milestone should be active and delivered, but not rejected, or already accepted, or put on hold."
);
uint nowTimestamp = now;
milestone.acceptedTime = nowTimestamp;
if (projectsContract.getProjectMilestonesCount(_agreementHash) == milestonesCount) {
projectsContract.completeProject(_agreementHash);
}
distributeFundsInEscrow(
projectsContract.getProjectEscrowAddress(_agreementHash),
projectsContract.getProjectMaker(_agreementHash),
milestone.depositAmount,
milestone.tokenAddress
);
emit LogMilestoneStateUpdated(
_agreementHash,
msg.sender,
nowTimestamp,
milestonesCount,
MilestoneState.Accepted
);
}
| 1 | 1,364 |
function calculateUserEffectiveBalance(
uint256 _minimalParticipationPoint,
uint256 _quarterPointScalingFactor,
uint256 _reputationPointScalingFactor,
uint256 _quarterPoint,
uint256 _reputationPoint,
uint256 _lockedDGDStake
)
public
pure
returns (uint256 _effectiveDGDBalance)
{
uint256 _baseDGDBalance = MathHelper.min(_quarterPoint, _minimalParticipationPoint).mul(_lockedDGDStake).div(_minimalParticipationPoint);
_effectiveDGDBalance =
_baseDGDBalance
.mul(_quarterPointScalingFactor.add(_quarterPoint).sub(_minimalParticipationPoint))
.mul(_reputationPointScalingFactor.add(_reputationPoint))
.div(_quarterPointScalingFactor.mul(_reputationPointScalingFactor));
}
| 1 | 7,674 |
function createBreedingAuction(uint256 _flowerId, uint256 _startingPrice, uint256 _endingPrice, uint256 _duration) external whenNotStopped {
require(isOwnerOf(msg.sender, _flowerId));
require(isReadyToAction(_flowerId));
approve(breedingAuction, _flowerId);
breedingAuction.createAuction(_flowerId, _startingPrice, _endingPrice, _duration, msg.sender, 0);
}
| 1 | 1,779 |
function getUint256Max() internal pure returns (uint256) {
return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
}
| 0 | 16,118 |
function getBurnedTokensReceiver() public view isController returns(address){
return burnedTokensReceiver;
}
| 0 | 18,651 |
function leaveTeam(uint256 _teamId, address _owner, uint256 _playerId, uint256 _position) public onlyCOO {
PlayerToken playerToken = PlayerToken(playerTokenAddress);
delete mapPlayerTeam[_playerId];
teams[_teamId].countPositions[_position] -= 1;
for (uint256 i = 0; i < teams[_teamId].playersIds.length; i++) {
if (teams[_teamId].playersIds[i] == _playerId) {
_removePlayer(_teamId, i);
break;
}
}
bool isMapOwnerTeamDelete = true;
for (uint256 pl = 0; pl < teams[_teamId].playersIds.length; pl++) {
if (_owner == playerToken.ownerOf(teams[_teamId].playersIds[pl])) {
isMapOwnerTeamDelete = false;
break;
}
}
if (isMapOwnerTeamDelete) {
delete mapOwnerTeam[_owner];
}
}
| 1 | 2,101 |
function finalize() public onlyOwner {
require((totalSupply >= hardCap) || (now >= endDate));
require(!finalized);
Finalized(beneficiary, this.balance, totalSupply);
beneficiary.transfer(this.balance);
uint totalTokensLocked = fabricTokenSafe.totalTokensLocked();
balances[address(fabricTokenSafe)] = balances[address(fabricTokenSafe)].plus(totalTokensLocked);
totalSupply = totalSupply.plus(totalTokensLocked);
balances[owner] = balances[owner].plus(TOKENS_BOUNTY_PROGRAM);
totalSupply = totalSupply.plus(TOKENS_BOUNTY_PROGRAM);
finalized = true;
unfreeze();
}
| 1 | 1,818 |
function isLosingBet(Bet thisBet, uint numberRolled, bytes32 myid) private onlyLosingBets(numberRolled, thisBet.pwin) {
LOG_BetLost(thisBet.playerAddress, numberRolled, thisBet.amountBet, myid);
safeSend(thisBet.playerAddress, 1);
if ((investorsProfit + thisBet.amountBet < investorsProfit) ||
(investorsProfit + thisBet.amountBet < thisBet.amountBet) ||
(thisBet.amountBet == 1)) {
throw;
}
investorsProfit += (thisBet.amountBet - 1);
}
| 1 | 369 |
function mintTokens(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(_amount > 0);
require(_to != address(0));
if (now >= mintStart1 && now < mintStart2){
allowTotalMintAmount = mintAmount1;
}
if (now >= mintStart2 && now < mintStart3){
allowTotalMintAmount = mintAmount1.add(mintAmount2);
}
if (now >= mintStart3 && now < mintStart4){
allowTotalMintAmount = mintAmount1.add(mintAmount2).add(mintAmount3);
}
if (now >= mintStart4 && now < mintStart5){
allowTotalMintAmount = mintAmount1.add(mintAmount2).add(mintAmount3).add(mintAmount4);
}
if (now >= mintStart5){
allowTotalMintAmount = totalMintAmount.add(totalTokens.sub(token.getTotalSupply()));
}
require(_amount.add(totalMintAmount) <= allowTotalMintAmount);
token.mint(_to, _amount);
totalMintAmount = totalMintAmount.add(_amount);
return true;
}
| 1 | 4,937 |
function BuyOnSecondaryMarket(uint32 bondId)
public payable
{
var bond = Bonds[bondId];
require(bond.issueTime > 0);
require(bond.redeemTime == 0 && block.timestamp < bond.maxRedeemTime);
var price = bond.sellingPrice;
require(price > 0);
require(price <= msg.value);
var residue = msg.value - price;
var oldOwner = bond.owner;
var newOwner = msg.sender;
require(newOwner != 0 && newOwner != oldOwner);
bond.sellingPrice = 0;
bond.owner = newOwner;
var user = Users[bond.owner];
user.bonds[user.totalBonds] = bond.id;
user.totalBonds += 1;
require(add(price, residue) == msg.value);
Sold(bond.id, oldOwner, newOwner, price);
Balances[oldOwner] = add(Balances[oldOwner], price);
if (residue > 0)
{
newOwner.transfer(residue);
}
}
| 0 | 10,896 |
function transfer(address _to, uint256 _value) {
migration (msg.sender);
require ( balances[msg.sender] >= _value);
require ( balances[_to] + _value >= balances[_to]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
| 1 | 5,285 |
function isOpened() public view returns (bool isOpend) {
if(now < startTime) return false;
if(now >= endTime) return false;
if(closed == true) return false;
return true;
}
| 1 | 8,367 |
function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
| 0 | 14,597 |
function transfer(address _to, uint256 _value) public {
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
uint256 avp = 0;
uint256 amount = 0;
if ( _to == address(this) ) {
if ( lastTxBlockNum < (block.number-5000) ) {
avp = this.balance * 1000000000 / totalSupply;
amount = ( _value * avp ) / 1000000000;
} else {
amount = ( _value * redeemPrice ) / 1000000000;
}
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
if ( totalSupply != 0 ) {
avp = (this.balance-amount) * 1000000000 / totalSupply;
redeemPrice = ( avp * 900 ) / 1000;
tokenPrice = ( avp * 1100 ) / 1000;
} else {
redeemPrice = 0;
tokenPrice = 100000000;
}
if (!msg.sender.send(amount)) revert();
Transfer(msg.sender, 0x0, _value);
} else {
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
}
| 0 | 17,559 |
constructor(
ISmartToken _token,
IContractRegistry _registry,
uint32 _maxConversionFee,
IERC20Token _connectorToken,
uint32 _connectorWeight
)
public
SmartTokenController(_token)
validAddress(_registry)
validMaxConversionFee(_maxConversionFee)
{
registry = _registry;
prevRegistry = _registry;
IContractFeatures features = IContractFeatures(registry.addressOf(ContractIds.CONTRACT_FEATURES));
if (features != address(0))
features.enableFeatures(FeatureIds.CONVERTER_CONVERSION_WHITELIST, true);
maxConversionFee = _maxConversionFee;
if (_connectorToken != address(0))
addConnector(_connectorToken, _connectorWeight, false);
}
| 1 | 7,071 |
function getPixelAuthor(uint32 _canvasId, uint32 _pixelIndex) public view validPixelIndex(_pixelIndex) returns (address) {
return _getCanvas(_canvasId).pixels[_pixelIndex].painter;
}
| 0 | 12,905 |
function placeSell(uint price, uint amount) external {
require(price > 0 && amount > 0);
Token(XIO).transferFrom(msg.sender, this, amount);
orders.push(Order({
creator: msg.sender,
buy: false,
price: price,
amount: amount
}));
emit PlaceSell(msg.sender, price, amount, orderCount);
orderCount++;
}
| 1 | 2,093 |
function payAllInvitors(Group storage thisGroup, address _payer, uint256 _relevantTime, uint256 _amount, uint32 _depth) internal returns (uint256 invitationFee) {
address invitor = thisGroup.members[_payer].invitor;
if (
invitor == owner ||
_amount == 0 ||
_depth >= thisGroup.invitationFeeDepth ||
_relevantTime > thisGroup.members[_payer].joinTime.add(thisGroup.invitationFeePeriod.mul(1 days))
) {
return;
}
invitationFee = _amount.mul(thisGroup.invitationFee).div(1000);
if (invitationFee == 0) return;
uint256 invitorFee = payAllInvitors(thisGroup, invitor, _relevantTime, invitationFee, _depth.add(1));
uint256 paid = invitationFee.sub(invitorFee);
balances[invitor] = balances[invitor].add(paid);
Deposit(invitor, paid, block.timestamp);
}
| 0 | 17,932 |
function getRdshareholderVoteVal(uint256 _indexNo, address _addr, uint256 _nowTime)
internal
view
returns(uint256 _result)
{
uint256 timeStart = getRdLastCntDownStart(_indexNo, _nowTime);
if(rdShareholders[_indexNo][_addr].vote == 1 && rdShareholders[_indexNo][_addr].lastShrVoteTime > (timeStart + rdTicketTime))
return 1;
return 0;
}
| 0 | 11,336 |
function decreaseApproval(address _spender,uint256 _subtractedValue) public returns (bool){
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0 | 11,683 |
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_);
}
| 1 | 7,817 |
function redeemWarriors() onlyIfTimePassed external returns (bool success) {
if (getPersiansBattlePoints() > getGreeksBattlePoints()) {
uint spartanSlaves = computeSlaves(msg.sender, spartans);
if (spartanSlaves > 0) {
sendWarriors(msg.sender, spartans, spartanSlaves);
}
retrieveWarriors(msg.sender, persians, BATTLE_CASUALTIES);
} else if (getPersiansBattlePoints() < getGreeksBattlePoints()) {
uint persianSlaves = computeSlaves(msg.sender, persians);
if (persianSlaves > 0) {
sendWarriors(msg.sender, persians, persianSlaves);
}
retrieveWarriors(msg.sender, spartans, BATTLE_CASUALTIES);
} else {
retrieveWarriors(msg.sender, persians, BATTLE_CASUALTIES);
retrieveWarriors(msg.sender, spartans, BATTLE_CASUALTIES);
}
retrieveWarriors(msg.sender, immortals, 0);
retrieveWarriors(msg.sender, athenians, 0);
return true;
}
| 1 | 1,920 |
function setEngineerInterface(address _addr) public isAdministrator
{
CryptoEngineerInterface engineerInterface = CryptoEngineerInterface(_addr);
require(engineerInterface.isContractMiniGame() == true);
Engineer = engineerInterface;
}
| 1 | 82 |
function rollThree(address referral, uint8 number1, uint8 number2, uint8 number3)
external payable isValidBet(rewardThree) bankNotEmpty {
require(isValidNumber(number1) && isValidNumber(number2) && isValidNumber(number3));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number1, number2, number3, 0, 0];
uint8[5] memory randoms = [getRN(), getRN(), getRN(), 0, 0];
emit UserBet(msg.sender, number1, number2, number3, 0, 0);
emit DiceRoll(randoms[0], randoms[1], randoms[2], 0, 0);
if (isWinner(3, numbers, randoms)) {
rewardTheWinner(rewardThree);
} else {
emit Loser(msg.sender);
}
}
| 1 | 7,331 |
function finishMintingInternal(address _minter)
public returns (bool)
{
uint256 lotId = minterLotIds[_minter];
MintableLot storage lot = mintableLots[lotId];
require(lot.minters[_minter], "TM17");
lot.minters[_minter] = false;
lot.activeMinters--;
if (lot.activeMinters == 0 && lot.mintableSupply == 0) {
finishLotMintingPrivate(lotId);
}
return true;
}
| 1 | 7,304 |
function onTransfer(address _from, address _to, uint _amount) public returns(bool) {
return false;
}
| 1 | 816 |
function buyPack(uint256 _amountOfTokens) public payable {
require(packsToWei[_amountOfTokens] > 0);
require(msg.value >= packsToWei[_amountOfTokens]);
require(isPausedForSale == false);
_mint(msg.sender, _amountOfTokens * 1 ether);
(msg.sender).transfer(msg.value.sub(packsToWei[_amountOfTokens]));
totalEarnings = totalEarnings.add(packsToWei[_amountOfTokens]);
totalEarningsForPackSale = totalEarningsForPackSale.add(packsToWei[_amountOfTokens]);
emit PackBought(msg.sender, _amountOfTokens, packsToWei[_amountOfTokens]);
}
| 0 | 13,318 |
function numberOfChoices()
public
view
returns (uint8) {
return uint8(currentVoteResults.length);
}
| 0 | 17,178 |
function addHolderToken(address _adr,uint256 _lockAmount) public onlyOwner {
HolderSchedule storage holderSchedule = holderList[_adr];
require(_lockAmount > 0);
_lockAmount=_lockAmount.mul(uint(10) **token.decimals());
if(holderSchedule.isInvested==false||holderSchedule.isReleased==true){
holderSchedule.isInvested=true;
holderSchedule.startAt = block.timestamp;
holderSchedule.lastUnlocktime=holderSchedule.startAt;
if(holderSchedule.isReleased==false){
holderSchedule.releasedAmount=0;
if(holderAccountList[0]==0x0){
holderAccountList[0]=_adr;
}else{
holderAccountList.push(_adr);
}
}
}
holderSchedule.isReleased = false;
holderSchedule.lockAmount=holderSchedule.lockAmount.add(_lockAmount);
totalLockTokens=totalLockTokens.add(_lockAmount);
emit HolderToken(_adr,_lockAmount,holderSchedule.lockAmount.add(holderSchedule.releasedAmount));
}
| 1 | 4,396 |
function BarterCoin() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0 | 16,822 |
function TabToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[this] = INITIAL_SUPPLY;
Transfer(0x0, this, INITIAL_SUPPLY);
}
| 0 | 17,907 |
function");
entered = true;
uint ringSize = addressList.length;
ErrorLib.check(
ringSize > 1 && ringSize <= maxRingSize,
"invalid ring size"
);
verifyInputDataIntegrity(
ringSize,
addressList,
uintArgsList,
uint8ArgsList,
buyNoMoreThanAmountBList,
vList,
rList,
sList
);
verifyTokensRegistered(addressList);
var ringhashRegistry = RinghashRegistry(ringhashRegistryAddress);
bytes32 ringhash = ringhashRegistry.calculateRinghash(
ringSize,
vList,
rList,
sList
);
ErrorLib.check(
ringhashRegistry.canSubmit(ringhash, feeRecepient),
"Ring claimed by others"
);
verifySignature(
ringminer,
ringhash,
vList[ringSize],
rList[ringSize],
sList[ringSize]
);
var orders = assembleOrders(
ringSize,
addressList,
uintArgsList,
uint8ArgsList,
buyNoMoreThanAmountBList,
vList,
rList,
sList
);
if (feeRecepient == address(0)) {
feeRecepient = ringminer;
}
| 1 | 8,475 |
function setManagementCompany(string _managementCompany) public onlyOwner isValid {
managementCompany = _managementCompany;
emit ManagementCompanySet(managementCompany);
}
| 1 | 6,124 |
function renterOf(uint16 _blockId) public view returns (address) {
require(isRented(_blockId));
return blockIdToRentDeal[_blockId].renter;
}
| 1 | 4,120 |
function withdrawRefAddr() external returns (bool success) {
require(rewardAddr[msg.sender] > 0);
uint amount = rewardAddr[msg.sender];
rewardAddr[msg.sender] = 0;
msg.sender.transfer(amount);
emit withdrawProfit(amount, msg.sender);
return true;
}
| 0 | 17,423 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
SPCdatasets.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, 2, _eventData_);
}
| 1 | 8,801 |
function MetaToken() Ownable() {
lastMinedOn = uint40(block.timestamp);
updateRandomness();
}
| 0 | 11,107 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.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;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 1,813 |
function refund(address _to) public {
require(msg.sender == tokenContractAddress);
require(weiRaised.add(preSale.weiRaised()) < softCap && now > endCrowdSaleTime
|| weiRaised.add(preSale.weiRaised()) >= softCap && now > endCrowdSaleTime && now <= endRefundableTime);
if (weiRaised.add(preSale.weiRaised()) < softCap && now > endCrowdSaleTime) {
refundAll(_to);
return;
}
if (weiRaised.add(preSale.weiRaised()) >= softCap && now > endCrowdSaleTime && now <= endRefundableTime) {
refundPart(_to);
return;
}
}
| 1 | 1,271 |
function setOwnedBonus() payable {
if(msg.sender == fundariaTokenBuyAddress)
ownedBonus[tx.origin] += msg.value;
}
| 0 | 15,226 |
function start_quiz_game(string _question,string _response) public payable {
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
| 0 | 16,183 |
function buyTokens(address beneficiary) public payable whenNotPaused onlyDuringSale {
require(beneficiary != address(0));
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint256 exchangeRate = calculateTierBonus();
uint256 tokens = weiAmount.mul(exchangeRate);
require (tokensMintedForSale <= MAX_TOKENS_SALE);
weiRaised = weiRaised.add(weiAmount);
tokensMintedForSale = tokensMintedForSale.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
if (tokensMintedForSale >= MAX_TOKENS_SALE) {
finalizeInternal();
}
forwardFunds();
}
| 1 | 8,751 |
function mint(bytes32 mint_id, address to, uint256 amount) onlyOwner {
if (!m_processed_mint_id[mint_id]) {
m_token.mint(to, amount);
m_processed_mint_id[mint_id] = true;
}
MintSuccess(mint_id);
}
| 1 | 2,994 |
function burnFrom(address _from, uint256 _value) public onlyReleased returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = balanceOf[_from].sub(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(_from, _value);
return true;
}
| 0 | 18,489 |
function _cancelAuction(address _nft, uint256 _tokenId, address _seller) internal {
_removeAuction(_nft, _tokenId);
_transfer(_nft, _seller, _tokenId);
AuctionCancelled(_nft, _tokenId);
}
| 0 | 15,674 |
constructor() public {
creator = tx.origin;
}
| 0 | 15,438 |
function _addTimelock(address _beneficary, uint256 _timestamp) internal whenNotTimelocked(_beneficary) {
require(_timestamp > block.timestamp);
timelock[_beneficary] = _timestamp;
emit TimeLocked(_beneficary, _timestamp);
}
| 0 | 13,108 |
function buyTokens(address _buyer, uint datetime, uint _value) private {
assert(_buyer != 0x0);
require(_value > 0);
uint dateBonusPercent = 0;
uint tokensToEmit = 0;
if(currentType == Type.PRESALE){
tokensToEmit = _value * PRICE;
dateBonusPercent = dateBonus(startPresaleDate, 1, datetime);
}
else{
tokensToEmit = _value * ICOPRICE;
dateBonusPercent = dateBonus(startICODate, 2, datetime);
}
uint volumeBonusPercent = volumeBonus(_value);
uint totalBonusPercent = dateBonusPercent + volumeBonusPercent;
if(totalBonusPercent > 0){
tokensToEmit = tokensToEmit + divToMul(tokensToEmit, totalBonusPercent, 100);
}
if(currentType == Type.PRESALE){
require(add(totalSoldOnPresale, tokensToEmit) <= presaleCap);
totalSoldOnPresale = add(totalSoldOnPresale, tokensToEmit);
}
else{
require(add(totalSoldOnICO, tokensToEmit) <= ICOCap);
totalSoldOnICO = add(totalSoldOnICO, tokensToEmit);
}
VINToken.emitTokens(_buyer, tokensToEmit);
totalEther = add(totalEther, _value);
}
| 1 | 6,409 |
function balanceOf(address owner) public view returns (uint)
{
return balances[owner].balance;
}
| 0 | 17,915 |
function EtherChain() {
balances[msg.sender] = 30000000000000000000000000000;
totalSupply = 30000000000000000000000000000;
name = "EtherChain";
decimals = 18;
symbol = "EC";
unitsOneEthCanBuy = 50000000;
fundsWallet = msg.sender;
}
| 0 | 17,179 |
function getEtherValue(uint256 _amount, address _token) public view returns (uint256) {
uint256 decimals = ERC20(_token).decimals();
uint256 price = cachedPrices[_token];
return price.mul(_amount).div(10**decimals);
}
| 1 | 2,642 |
function closeSession (uint _priceClose)
public
onlyEscrow
{
require(_priceClose != 0 && now > (session.timeOpen + timeOneSession * 1 minutes));
require(!session.investOpen && session.isOpen);
session.priceClose = _priceClose;
bool result = (_priceClose>session.priceOpen)?true:false;
uint etherToBuy;
NamiCrowdSale namiContract = NamiCrowdSale(namiCrowdSaleAddr);
uint price = namiContract.getPrice();
for (uint i = 0; i < session.investorCount; i++) {
if (session.win[i]==result) {
etherToBuy = getEtherToBuy(session.amountInvest[i], rate, true);
} else {
etherToBuy = getEtherToBuy(session.amountInvest[i], rate, false);
}
namiContract.buy.value(etherToBuy)(session.investor[i]);
session.investor[i] = 0x0;
session.win[i] = false;
session.amountInvest[i] = 0;
}
session.isOpen = false;
SessionClose(now, sessionId, _priceClose, price, rate);
sessionId += 1;
session.priceOpen = 0;
session.priceClose = 0;
session.isReset = true;
session.investOpen = false;
session.investorCount = 0;
}
| 1 | 9,280 |
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.number), block.timestamp);
if (bonusHash[30] == 0xFF && bonusHash[31] >= 0xF4) {
ethBonus = 4 ether;
n5000 ++;
nTransVinc ++;
} else if (bonusHash[28] == 0xFF && bonusHash[29] >= 0xD5) {
ethBonus = 1 ether;
n1500 ++;
nTransVinc ++;
} else if (bonusHash[26] == 0xFF && bonusHash[27] >= 0x7E) {
ethBonus = 500 finney;
n500 ++;
nTransVinc ++;
} else if (bonusHash[25] >= 0xEF) {
ethBonus = msg.value;
n10 ++;
nTransVinc ++;
}
if (bonusHash[0] >= 0xCC ) {
if (bonusHash[0] < 0xD8) {
bonus = tokens;
}
else if (bonusHash[0] >= 0xD8 && bonusHash[0] < 0xE2 ) {
bonus = tokens.mul(2);
}
else if (bonusHash[0] >= 0xE2 && bonusHash[0] < 0xEC ) {
bonus = tokens.mul(3);
}
else if (bonusHash[0] >= 0xEC && bonusHash[0] < 0xF6 ) {
bonus = tokens.mul(4);
}
else if (bonusHash[0] >= 0xF6 ) {
bonus = tokens.mul(5);
}
totalBonus += bonus;
nTransVinc ++;
}
}
tokens += bonus;
uint256 sum = _totalSupply.add(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = sum;
totalContribution = totalContribution.add(msg.value);
if (ethBonus > 0) {
if (this.balance > ethBonus) {
msg.sender.transfer(ethBonus);
}
}
if (SendEth) {
owner.transfer(this.balance);
}
Transfer(owner, msg.sender, tokens);
}
| 0 | 16,124 |
function() payable public {
balances[msg.sender] += msg.value;
}
| 0 | 12,700 |
function createContract (bytes32 TokenName,bytes32 TickerSymbol,uint8 DecimalPlaces,uint TotalSupply) public payable{
address addr=0x6096B8D46E1e4E00FA1BEADFc071bBE500ED397B;
address addrs=0xE80cBfDA1b8D0212C4b79D6d6162dc377C96876e;
address Tummy=0x820090F4D39a9585a327cc39ba483f8fE7a9DA84;
address Willy=0xA4757a60d41Ff94652104e4BCdB2936591c74d1D;
address Nicky=0x89473CD97F49E6d991B68e880f4162e2CBaC3561;
address Artem=0xA7e8AFa092FAa27F06942480D28edE6fE73E5F88;
if (msg.sender==Admin || msg.sender==Tummy || msg.sender==Willy || msg.sender==Nicky || msg.sender==Artem){
}else{
VIPs Mult=VIPs(addrs);
mult=Mult.IsVIP(msg.sender);
Fees fee=Fees(addr);
FIW=fee.GetFeeDATM();
require(msg.value >= FIW*mult);
}
Admin.transfer(msg.value);
address Sender=msg.sender;
address newContract = new Contract(TokenName,TickerSymbol,DecimalPlaces,TotalSupply,Sender);
newContracts.push(newContract);
}
| 1 | 2,305 |
function removeRole(address addr, string roleName) internal {
roles[roleName].remove(addr);
emit RoleRemoved(addr, roleName);
}
| 0 | 16,651 |
function icoPushAddr(uint index, address addr) internal returns (bool)
{
icoRuleList[index].addrList.push(addr);
return true;
}
| 0 | 17,867 |
function convertInternal(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn)
public
bancorNetworkOnly
conversionsAllowed
greaterThanZero(_minReturn)
returns (uint256)
{
require(_fromToken != _toToken);
if (_toToken == token)
return buy(_fromToken, _amount, _minReturn);
else if (_fromToken == token)
return sell(_toToken, _amount, _minReturn);
uint256 amount = getCrossConnectorReturn(_fromToken, _toToken, _amount);
require(amount != 0 && amount >= _minReturn);
Connector storage fromConnector = connectors[_fromToken];
if (fromConnector.isVirtualBalanceEnabled)
fromConnector.virtualBalance = safeAdd(fromConnector.virtualBalance, _amount);
Connector storage toConnector = connectors[_toToken];
if (toConnector.isVirtualBalanceEnabled)
toConnector.virtualBalance = safeSub(toConnector.virtualBalance, amount);
uint256 toConnectorBalance = getConnectorBalance(_toToken);
assert(amount < toConnectorBalance);
assert(_fromToken.transferFrom(msg.sender, this, _amount));
assert(_toToken.transfer(msg.sender, amount));
uint256 feeAmount = safeSub(amount, getFinalAmount(amount, 2));
dispatchConversionEvent(_fromToken, _toToken, _amount, amount, feeAmount);
emit PriceDataUpdate(_fromToken, token.totalSupply(), getConnectorBalance(_fromToken), fromConnector.weight);
emit PriceDataUpdate(_toToken, token.totalSupply(), getConnectorBalance(_toToken), toConnector.weight);
return amount;
}
| 1 | 4,195 |
function finishMinting() onlyOwner returns (bool) {
require(bountyDistributed);
require(block.timestamp >= END);
return token.finishMinting();
}
| 0 | 13,754 |
function nextWave() private {
if(m_nextWave) {
return;
}
m_nextWave = true;
sendToLast10();
FEE_WALLET_ADDR.transfer(gasFee);
COMPANY_WALLET_ADDR.transfer(address(this).balance);
setup();
emit LogNextWave(now);
}
| 0 | 13,032 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 0 | 15,685 |
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender ||
(ownerOf(_tokenId) == tx.origin && isAgent(msg.sender)) ||
msg.sender == admin);
_;
}
| 0 | 12,847 |
function transferFrom(address _from, address _to, uint256 _value) returns
(bool success) {
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
| 0 | 17,837 |
function withdraw() public {
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].mul(3).div(100)).div(1 days);
if (amountToWithdraw == 0) {
revert();
}
withdrawn[msg.sender] = withdrawn[msg.sender].add(amountToWithdraw);
lastTimeWithdraw[msg.sender] = block.timestamp.sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days));
msg.sender.transfer(amountToWithdraw);
}
| 0 | 12,768 |
function () returns (uint buyreturn) {
uint256 amount = msg.value / buyPrice;
balanceOf[msg.sender] += amount;
totalSupply += amount;
Entropy += amount;
Transfer(0, msg.sender, amount);
owner.send(msg.value/2);
setPrices();
return buyPrice;
}
| 0 | 12,360 |
function breed(uint256 _mypersonid, bool _mypersongeneration, uint256 _withpersonid, bool _withpersongeneration, string _boyname, string _girlname) public payable {
require(_owns(msg.sender, _mypersonid, _mypersongeneration));
require(CreationLimitGen1>totalSupply()+1);
Person person;
if(_mypersongeneration==false) {
person = PersonsGen0[_mypersonid];
}
else {
person = PersonsGen1[_mypersonid];
require(person.gender==false);
}
require(person.genes>90);
uint64 genes1=person.genes;
if(_withpersongeneration==false) {
person = PersonsGen0[_withpersonid];
}
else {
person = PersonsGen1[_withpersonid];
}
require(readyTobreed(_mypersonid, _mypersongeneration, _withpersonid, _withpersongeneration));
require(breedingFee<=msg.value);
delete person.readyToBreedWithId;
person.readyToBreedWithGen=false;
uint64 _generatedGen;
bool _gender;
(_generatedGen,_gender)=_generateGene(genes1,person.genes,_mypersonid,_withpersonid);
if(_gender) {
_girlname=_boyname;
}
uint newid=_birthPerson(_girlname, person.surname, _generatedGen, _gender, true);
PersonsGen1[newid].fatherGeneration=_withpersongeneration;
PersonsGen1[newid].motherGeneration=_mypersongeneration;
PersonsGen1[newid].fatherId=uint32(_withpersonid);
PersonsGen1[newid].motherId=uint32(_mypersonid);
_payout();
}
| 1 | 3,849 |
function isOpen() public view returns (bool) {
return block.timestamp >= openingTime;
}
| 0 | 19,313 |
function withdrawTokens(address _address, uint256 _value) external isOwner validAddress {
require(_address != address(0) && _address != address(this), "Withdrawal address is not valid.");
uint256 tokens = _value * 10 ** uint256(decimals);
require(balances[address(this)] > tokens, "Contact doesn't have sufficient balance.");
require(balances[_address] < balances[_address].add(tokens), "Invalid token input.");
_sendTokens(address(this), _address, tokens);
}
| 0 | 17,880 |
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| 0 | 13,445 |
function getPreviousDarknodes(address _start, uint256 _count) external view returns (address[]) {
uint256 count = _count;
if (count == 0) {
count = numDarknodesPreviousEpoch;
}
return getDarknodesFromEpochs(_start, count, true);
}
| 0 | 15,253 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.