func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function mint(address, uint256) public returns (bool);
}
contract SecondBountyWPTpayout_part1 {
address public owner;
Token public company_token;
address[] public addressOfBountyMembers;
mapping(address => uint256) bountyMembersAmounts;
uint currentBatch;
uint addrPerStep;
modifier onlyOwner
{
require(owner == msg.sender);
_;
}
| 0 | 14,569 |
function () public payable {
require(block.timestamp >= startTime);
require(tx.gasprice <= GAS_PRICE_MAX);
if(msg.value > 0){
require(gasleft() >= 250000);
require(msg.value >= 0.05 ether && msg.value <= 10 ether);
queue.push( Deposit(msg.sender, msg.value, 0) );
depositNumber[msg.sender] = queue.length;
totalInvested += msg.value;
uint promo1 = msg.value*PROMO_PERCENT/100;
PROMO1.send(promo1);
uint promo2 = msg.value*PROMO_PERCENT/100;
PROMO2.send(promo2);
uint promo3 = msg.value*PROMO_PERCENT/100;
PROMO3.send(promo3);
uint prize = msg.value*BONUS_PERCENT/100;
PRIZE.send(prize);
pay();
}
}
| 0 | 10,099 |
function swap(uint256 sendAmount) returns (bool success){
require(tokenSwapSupply >= sendAmount * 3);
if(ERC20(oldAddress).transferFrom(msg.sender, tokenAdmin, sendAmount)){
balanceOf[msg.sender] += sendAmount * 3;
tokenSwapSupply -= sendAmount * 3;
}
return true;
}
| 1 | 9,456 |
function setOwner(address _owner) onlyOwner() public {
owner = _owner;
}
| 0 | 15,047 |
function stopIco() public returns (bool success) {
if (block.timestamp > fundingEndTime) {
ico_finish = true;
return true;
}
}
| 0 | 12,433 |
constructor()
HasOwner(msg.sender)
public
{
token = new TIMEToken(
address(this)
);
tokenSafe = new TIMETokenSafe(token);
MintableToken(token).mint(address(tokenSafe), 840000000000000000000000);
initializeBasicFundraiser(
1543622400,
1893455940,
1,
0x5A9308C700e7b5c3fEE6bEAA0fc96Dcf06698A24
);
initializeIndividualCapsFundraiser(
(0 ether),
(0 ether)
);
initializeGasPriceLimitFundraiser(
200000000000000
);
initializePresaleFundraiser(
2400000000000000000000000,
1542387600,
1543622340,
1
);
}
| 1 | 5,650 |
function totalAvailable() public view returns (uint256 available) {
available = balances[owner].sub(totalCirculated_);
}
| 0 | 13,684 |
function adminWithdraw(uint256 _amount) public {
uint256 perFounder = _amount / 3;
address(0xD5d6301dE62D82F461dC29824FC597D38d80c424).transfer(perFounder);
address(0x1E4F1275bB041586D7Bec44D2E3e4F30e0dA7Ba4).transfer(perFounder);
address(0xe1811eC49f493afb1F4B42E3Ef4a3B9d62d9A01b).transfer(perFounder);
}
| 0 | 18,601 |
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
return c;
}
| 0 | 16,565 |
function setStartTime(uint _startTime) public onlyOwner {
require(now < openingTime);
require(_startTime > openingTime);
require(_startTime < closingTime);
emit TimesChanged(_startTime, closingTime, openingTime, closingTime);
openingTime = _startTime;
}
| 1 | 8,052 |
function isValidPurchase(uint256 value, uint256 amount) internal constant returns (bool) {
bool validTimestamp = startingTimestamp <= block.timestamp && endingTimestamp >= block.timestamp;
bool validValue = value != 0;
bool validRate = tokenPriceInEth > 0;
bool validAmount = tokensForSale.sub(totalTokenSold) >= amount && amount > 0;
return validTimestamp && validValue && validRate && validAmount && !isClose;
}
| 0 | 18,693 |
function _burn(address who, uint256 value) internal {
super._burn(who, value);
}
| 0 | 15,766 |
function determinePID(ZaynixKeyDatasets.EventReturns memory _eventData_)
private
returns (ZaynixKeyDatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 2,881 |
function setEarlyParticipantWhitelist(address participant, uint value) onlyOwner public {
require(value != 0 && participant != 0x0);
require(value <= pricingStrategy.getPresaleMaxValue());
assert(!pricingStrategy.isPresaleFull(whitelistWeiRaised));
if(earlyParticipantWhitelist[participant] > 0) {
whitelistWeiRaised = whitelistWeiRaised.sub(earlyParticipantWhitelist[participant]);
}
earlyParticipantWhitelist[participant] = value;
whitelistWeiRaised = whitelistWeiRaised.add(value);
Whitelisted(participant, value);
}
| 1 | 1,677 |
function createSale(uint256 _tokenId, uint256 _startingPrice, uint256 _endingPrice, uint256 _duration, address _owner) external;
}
contract DodgersNFT is CollectibleMinting {
address public newContractAddress;
string public constant MLB_Legal = "Major League Baseball trademarks and copyrights are used with permission of the applicable MLB entity. All rights reserved.";
uint32 public detachmentTime = 0;
bool public attachedSystemActive;
SaleManager public saleManagerAddress;
constructor() public {
paused = true;
managerPrimary = msg.sender;
managerSecondary = msg.sender;
bankManager = msg.sender;
name_ = "LucidSight-DODGERS-NFT";
symbol_ = "DNFTCB";
}
| 0 | 15,855 |
function _generateFighterStats(uint256 generation1, uint256 genes1, uint256 generation2, uint256 genes2) internal returns (uint256[6]) {
uint256 generation256 = ((generation1 + generation2) / 2) + 1;
if (generation256 > 65535)
generation256 = 65535;
uint16 generation = uint16(generation256);
uint256 genes = geneScience.mixGenes(genes1, genes2);
uint256 strength;
uint256 dexterity;
uint256 vitality;
uint256 rand = uint(keccak256(now, msg.sender, randomCounter++));
(strength, dexterity, vitality) = _getStrengthDexterityVitality(_getRaceFromGenes(genes), generation, rand);
uint256 luck = genToLuck(genes, rand);
return [
generation,
genes,
strength,
dexterity,
vitality,
luck
];
}
| 1 | 6,060 |
function burnAllTokens() public onlyOwner mustBeAtStage(Stage.Finalized) {
uint thisTokenBalance = token.balanceOf(address(this));
if (thisTokenBalance > 0) {
token.burn(thisTokenBalance);
}
}
| 1 | 901 |
function bid(uint16 auctionIndex, uint256 useFromPendingReturn) public payable whenNotPaused
{
Auction storage auction = auctions[auctionIndex];
address prevBidder = auction.highestBidder;
uint256 returnValue = auction.highestBid;
require (useFromPendingReturn <= pendingReturns[msg.sender]);
uint256 bank = useFromPendingReturn;
pendingReturns[msg.sender] -= bank;
totalReturns -= bank;
uint256 currentBid = bank + msg.value;
require(currentBid >= auction.highestBid + minBid ||
currentBid >= auction.highestBid && prevBidder == address(0));
require(isActive(auctionIndex));
auction.highestBid = uint128(currentBid);
auction.highestBidder = msg.sender;
auction.lastBidTime = uint40(now);
if (isActive(auctionIndex) && auction.timeEnd < now + minTime)
{
auction.timeEnd = uint40(now) + minTime;
}
emit Bid(msg.sender, prevBidder, currentBid, currentBid - returnValue, auctionIndex);
if (prevBidder != address(0))
{
if (!isContract(prevBidder))
{
if (prevBidder.send(returnValue))
{
return;
}
}
pendingReturns[prevBidder] += returnValue;
totalReturns += returnValue;
}
}
| 0 | 17,048 |
function burn(address _guy, uint _wad) auth stoppable {
super.burn(_guy, _wad);
Transfer(_guy, 0, _wad);
}
| 1 | 7,164 |
function() internal payable {
require(msg.value > 100000000000000000);
require(unsoldAmount > 0);
require(currentPrice > 0);
uint256 tokensNum = msg.value / currentPrice / 10;
if ( tokensNum > unsoldAmount ) {
tokensNum = unsoldAmount;
}
require(tokenAddress.transfer( msg.sender, tokensNum ));
unsoldAmount = unsoldAmount - tokensNum;
currentPrice = minPrice + ( maxPrice - minPrice ) * ( tokensForSale - unsoldAmount ) * 1000000 / ( tokensForSale * 1000000 );
}
| 1 | 2,296 |
function getArtToken(uint256 _id)
external
view
returns (
uint256 birthTime,
uint256 generator
) {
ArtToken storage art = artpieces[_id];
birthTime = uint256(art.birthTime);
generator = uint256(art.generator);
}
| 0 | 11,594 |
function () public payable {
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= 10 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo1 = msg.value*PROMO_PERCENT1/100;
PROMO1.send(promo1);
uint promo2 = msg.value*PROMO_PERCENT2/100;
PROMO2.send(promo2);
uint tech = msg.value*TECH_PERCENT/100;
TECH.send(tech);
pay();
}
}
| 0 | 13,632 |
function advanceTimedState()
private
{
if (_pastStateTransitionTimes[uint32(ETOState.Setup)] == 0) {
return;
}
uint256 t = block.timestamp;
if (_state == ETOState.Setup && t >= startOfInternal(ETOState.Whitelist)) {
transitionTo(ETOState.Whitelist);
}
if (_state == ETOState.Whitelist && t >= startOfInternal(ETOState.Public)) {
transitionTo(ETOState.Public);
}
if (_state == ETOState.Public && t >= startOfInternal(ETOState.Signing)) {
transitionTo(ETOState.Signing);
}
if (_state == ETOState.Signing && t >= startOfInternal(ETOState.Claim)) {
transitionTo(ETOState.Refund);
}
if (_state == ETOState.Claim && t >= startOfInternal(ETOState.Payout)) {
transitionTo(ETOState.Payout);
}
}
| 1 | 8,488 |
function sellItem(uint256 _tokenId)
whenNotPaused()
isHuman()
public
{
require(artItemMap[_tokenId].isExist == true, "item not exist");
require(artItemMap[_tokenId].owner == msg.sender,"player not own this item");
require(artItemMap[_tokenId].buyTime + artItemMap[_tokenId].lockDuration <= now,"the item still lock");
uint256 _sellPrice = (artItemMap[_tokenId].price).mul(artItemMap[_tokenId].annualRate).div(100).add(artItemMap[_tokenId].price);
bool _isSuccess = YbTokenContract.transfer(msg.sender, _sellPrice);
require(_isSuccess,"yb transfer failed");
artItemMap[_tokenId].owner = this;
artItemMap[_tokenId].lastTransPrice = artItemMap[_tokenId].price;
removePlayerOwnItem(_tokenId);
emit ArtChainEvents.onTransferItem ({
from: msg.sender,
to: this,
itemId: _tokenId,
price: artItemMap[_tokenId].price,
yibPrice: artItemMap[_tokenId].buyYibPrice,
timeStamp: now
});
}
| 1 | 9,713 |
function showDeposit (address _deposit) public view returns(uint256) {
return invested[_deposit];
}
| 0 | 17,643 |
function allocatePrivateSaleFunds(uint256 privateSaleSupplyAmount) public onlyOwner
{
require(privateSaleSupplyLimit.add(privateSaleSupplyAmount) < tokenSupplyLimit, "Token's private sale supply limit should be less that token supply limit.");
privateSaleSupplyLimit = privateSaleSupplyLimit.add(privateSaleSupplyAmount);
_deliverTokens(privateSaleManagerWallet, privateSaleSupplyAmount);
}
| 0 | 17,285 |
function() payable {
if (endRegisterTime == 0) {
endRegisterTime = now + registerDuration;
if (msg.value == 0)
throw;
StartedGame(msg.sender, endRegisterTime, msg.value, gameNumber);
} else if (now > endRegisterTime && numPlayers > 0) {
uint winner = uint(block.blockhash(block.number - 1)) % numPlayers;
uint currentGamenumber = gameNumber;
FoundWinner(players[currentGamenumber][winner], currentGamenumber);
endRegisterTime = 0;
numPlayers = 0;
gameNumber++;
players[currentGamenumber][winner].send(this.balance);
} else {
if (registered[gameNumber][msg.sender])
throw;
registered[gameNumber][msg.sender] = true;
players[gameNumber][numPlayers] = (msg.sender);
numPlayers++;
RegisteredPlayer(msg.sender, gameNumber);
}
}
| 0 | 13,536 |
function withdraw() onlyOwner public {
owner.transfer(address(this).balance);
}
| 1 | 8,219 |
function getLongShareSellerSource(Data _data) internal pure returns (address) {
return (_data.creator.direction == Direction.Short) ? _data.contracts.market : _data.filler.participantAddress;
}
| 0 | 13,968 |
function _getTokenAmount(uint256 _weiAmount) view internal returns (uint256) {
if(block.timestamp < secondRoundTime) return _weiAmount.mul(rateFirstRound);
if(block.timestamp < thirdRoundTime) return _weiAmount.mul(rateSecondRound);
return _weiAmount.mul(rateThirdRound);
}
| 0 | 16,768 |
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256[])
{
uint256[] memory _vaults = new uint256[](3);
_vaults[0] = plyr_[_pID].win;
_vaults[1] = plyr_[_pID].gen;
_vaults[2] = plyr_[_pID].aff;
return _vaults;
}
| 1 | 6,772 |
function verify(string sha256) constant returns (uint,uint16,uint16,uint16,uint16,uint16) {
var timestamp = proofs[sha256];
if ( timestamp == 0 ){
return (timestamp,0,0,0,0,0);
}else{
DateTime dt = DateTime(msg.sender);
uint16 year = dt.getYear(timestamp);
uint16 month = dt.getMonth(timestamp);
uint16 day = dt.getDay(timestamp);
uint16 hour = dt.getHour(timestamp);
uint16 minute = dt.getMinute(timestamp);
uint16 second = dt.getSecond(timestamp);
return (timestamp,year, month,day,hour,minute);
}
}
| 0 | 16,746 |
function getColors(uint32 start) public view returns (uint8[50000] ) {
require(start < 1000000);
uint8[50000] memory partialPixels;
for (uint32 i=0; i<50000; i++) {
partialPixels[i]=pixels[start+i];
}
return partialPixels;
}
| 0 | 11,923 |
function voteWithProfile(uint256[] candidateIndexes, address ERC725Address) public {
require(votingClosingTime != 0, "Voting has not yet started!");
require(votingClosingTime >= block.timestamp, "Voting period has expired!");
require(walletApproved[msg.sender] == true || walletApproved[ERC725Address] == true, "Sender is not approved and thus cannot vote!");
require(walletVoted[msg.sender] == false, "Sender already voted!");
require(walletVoted[ERC725Address] == false, "Profile was already used for voting!");
require(candidateIndexes.length == 3, "Must vote for 3 candidates!");
require(candidateIndexes[0] != candidateIndexes[1], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[1] != candidateIndexes[2], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[2] != candidateIndexes[0], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[0] >= 0 && candidateIndexes[0] < candidates.length, "The selected candidate does not exist!");
require(candidateIndexes[1] >= 0 && candidateIndexes[1] < candidates.length, "The selected candidate does not exist!");
require(candidateIndexes[2] >= 0 && candidateIndexes[2] < candidates.length, "The selected candidate does not exist!");
walletVoted[msg.sender] = true;
walletVoted[ERC725Address] = true;
emit WalletVoted(msg.sender, candidates[candidateIndexes[0]].name, candidates[candidateIndexes[1]].name, candidates[candidateIndexes[2]].name);
assert(candidates[candidateIndexes[0]].votes + 3 > candidates[candidateIndexes[0]].votes);
candidates[candidateIndexes[0]].votes = candidates[candidateIndexes[0]].votes + 3;
assert(candidates[candidateIndexes[1]].votes + 2 > candidates[candidateIndexes[1]].votes);
candidates[candidateIndexes[1]].votes = candidates[candidateIndexes[1]].votes + 2;
assert(candidates[candidateIndexes[2]].votes + 1 > candidates[candidateIndexes[2]].votes);
candidates[candidateIndexes[2]].votes = candidates[candidateIndexes[2]].votes + 1;
require(ERC725(ERC725Address).keyHasPurpose(keccak256(abi.encodePacked(msg.sender)), 2),
"Sender is not the management wallet for this ERC725 identity!");
require(tokenContract.balanceOf(msg.sender) >= 10^21 || profileStorageContract.getStake(ERC725Address) >= 10^21,
"Neither the sender nor the submitted profile have at least 1000 TRAC and thus cannot vote!");
}
| 0 | 11,440 |
function RewardWallet(address _returnWalletAddress) OwnedAccount(msg.sender) {
returnWalletAddress = _returnWalletAddress;
}
| 0 | 17,369 |
function calculateRate(uint256 _amount) public view returns(uint256) {
uint256 tokenPrice = fiat_contract.USD(0);
if(startTime.add(15 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(200).div(10 ** 8);
} else if(startTime.add(45 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(300).div(10 ** 8);
} else if(startTime.add(52 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(330).div(10 ** 8);
} else if(startTime.add(59 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(360).div(10 ** 8);
} else if(startTime.add(66 days) >= block.timestamp) {
tokenPrice = tokenPrice.mul(400).div(10 ** 8);
} else {
tokenPrice = tokenPrice.mul(150).div(10 ** 8);
}
return _amount.div(tokenPrice).mul(10 ** 10);
}
| 0 | 15,143 |
function goalReached() public constant returns (bool) {
return weiRaised >= dollarCost.mul(goal).mul(40).div(100);
}
| 1 | 7,257 |
function _distributeRegistrationBonus(address _recepient) internal returns (bool) {
uint registrationBonus = bonusStrategy.getCurrentBonus();
totalRegistrationBonusAmount = totalRegistrationBonusAmount.add(registrationBonus);
token.transfer(_recepient, registrationBonus);
return true;
}
| 1 | 2,580 |
function setBorrower(address _borrower) external checkIfArbiter {
require(_borrower != address(0), "No borrower set");
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "representative", _borrower))), "Borrower not registered representative");
borrower = _borrower;
emit onBorrowerChanged(borrower);
}
| 1 | 7,966 |
function redeemOrSellCoinsToICO(uint enter1forRedeemOR2forSell, uint256 amountOfCoinPartsToRedeemOrSell) public returns (bool success ) {
require(crowdSaleOpen == false);
uint amount = amountOfCoinPartsToRedeemOrSell;
msgSndr[msg.sender] = amount;
bool isPreview = false;
ICO ico = ICO(_getIcoAddr());
bool icosuccess ; uint redeemOrSellPaymentValue;
if(enter1forRedeemOR2forSell == 1){
(icosuccess , redeemOrSellPaymentValue) = ico.redeemCoin( amount, msg.sender, isPreview);
}
if(enter1forRedeemOR2forSell == 2){
(icosuccess , redeemOrSellPaymentValue) = ico.sell( amount, msg.sender, isPreview);
}
require( icosuccess == true);
require( _getIcoAddr().balance >= safeAdd( ico.getMinBal() , redeemOrSellPaymentValue) );
bool sucsTrTk = false; bool pymActSucs = false;
if(isPreview == false) {
sucsTrTk = _safeTransferTkn( msg.sender, owner, amount);
require(sucsTrTk == true);
msgSndr[msg.sender] = redeemOrSellPaymentValue;
pymActSucs = _safePaymentActionAtIco( redeemOrSellPaymentValue, msg.sender, enter1forRedeemOR2forSell);
require(pymActSucs == true);
}
msgSndr[msg.sender] = 0;
return (true);
}
| 1 | 2,156 |
function onRequestVotingRights(address user, uint tokenAmount) external;
}
pragma solidity ^0.4.24;
contract CivilTokenController is ManagedWhitelist, ERC1404, TokenTelemetryI {
using MessagesAndCodes for MessagesAndCodes.Data;
MessagesAndCodes.Data internal messagesAndCodes;
uint8 public constant SUCCESS_CODE = 0;
string public constant SUCCESS_MESSAGE = "SUCCESS";
uint8 public constant MUST_BE_A_CIVILIAN_CODE = 1;
string public constant MUST_BE_A_CIVILIAN_ERROR = "MUST_BE_A_CIVILIAN";
uint8 public constant MUST_BE_UNLOCKED_CODE = 2;
string public constant MUST_BE_UNLOCKED_ERROR = "MUST_BE_UNLOCKED";
uint8 public constant MUST_BE_VERIFIED_CODE = 3;
string public constant MUST_BE_VERIFIED_ERROR = "MUST_BE_VERIFIED";
constructor () public {
messagesAndCodes.addMessage(SUCCESS_CODE, SUCCESS_MESSAGE);
messagesAndCodes.addMessage(MUST_BE_A_CIVILIAN_CODE, MUST_BE_A_CIVILIAN_ERROR);
messagesAndCodes.addMessage(MUST_BE_UNLOCKED_CODE, MUST_BE_UNLOCKED_ERROR);
messagesAndCodes.addMessage(MUST_BE_VERIFIED_CODE, MUST_BE_VERIFIED_ERROR);
}
| 1 | 4,340 |
function () public payable {
require(msg.value>0);
require(white.isWhitelisted(msg.sender) == true);
require(!crowdsaleClosed);
require(now <= deadline && now >= start);
uint256 amount = (msg.value / getTokenPrice()) * 1 ether;
totalSold += (amount / tokenPrice) * 100;
if(tokenSold < 6000000)
{
amount = amount + ((amount * 25) / 100);
}
else if(tokenSold < 12000000)
{
amount = amount + ((amount * 15) / 100);
}
else
{
amount = amount + ((amount * 10) / 100);
}
ETHWallet.transfer(msg.value);
Token.transferFrom(owner, msg.sender, amount);
emit Contribution(msg.sender, amount);
}
| 0 | 12,936 |
function addPayment(
uint8 _payment_method,
uint8 _funding_stage
)
public
payable
requireInitialised
onlyManager
returns (bool)
{
if(msg.value > 0 && FundingEntity.allowedPaymentMethod(_payment_method)) {
PurchaseStruct storage purchase = purchaseRecords[++purchaseRecordsNum];
purchase.unix_time = now;
purchase.payment_method = _payment_method;
purchase.amount = msg.value;
purchase.funding_stage = _funding_stage;
purchase.index = purchaseRecordsNum;
if(_payment_method == 1) {
amount_direct+= purchase.amount;
stageAmountsDirect[_funding_stage]+=purchase.amount;
}
if(_payment_method == 2) {
amount_milestone+= purchase.amount;
}
stageAmounts[_funding_stage]+=purchase.amount;
EventPaymentReceived( purchase.payment_method, purchase.amount, purchase.index );
return true;
} else {
revert();
}
}
| 1 | 9,562 |
function decreaseApproval (address _spender, uint _subtractedValue)public returns (bool success);
}
contract IBoard is Ownable {
event CaseOpened(bytes32 caseId, address applicant, address respondent, bytes32 deal, uint amount, uint refereeAward, bytes32 title, string applicantDescription, uint[] dates, uint refereeCountNeed, bool isEthRefereeAward);
event CaseCommentedByRespondent(bytes32 caseId, address respondent, string comment);
event CaseVoting(bytes32 caseId);
event CaseVoteCommitted(bytes32 caseId, address referee, bytes32 voteHash);
event CaseRevealingVotes(bytes32 caseId);
event CaseVoteRevealed(bytes32 caseId, address referee, uint8 voteOption, bytes32 salt);
event CaseClosed(bytes32 caseId, bool won);
event CaseCanceled(bytes32 caseId, uint8 causeCode);
event RefereesAssignedToCase(bytes32 caseId, address[] referees);
event RefereeVoteBalanceChanged(address referee, uint balance);
event RefereeAwarded(address referee, bytes32 caseId, uint award);
address public lib;
uint public version;
IBoardConfig public config;
BkxToken public bkxToken;
address public admin;
address public paymentHolder;
modifier onlyOwnerOrAdmin() {
require(msg.sender == admin || msg.sender == owner);
_;
}
| 0 | 19,322 |
function _transfer(address _from, address _to, uint256 _value) internal {
require(_from != 0x0);
require(_to != 0x0);
require(_value > 0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to].add(_value) >= balanceOf[_to]);
require(_from != _to);
require(!webGiftUnTransfer(_from, _to));
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add( balanceOf[_to]) == previousBalances);
}
| 0 | 10,586 |
function ETHACE(){
owner = msg.sender;
balances[msg.sender] = CREATOR_TOKEN;
}
| 0 | 15,139 |
function canSpend(address tokenOwner, uint _value) public constant returns (bool success) {
if (_value > balances[tokenOwner].balance) {return false;}
if (tokenOwner==address(0)) {return false;}
if (tokenOwner==owner) {return true;}
if (_whitelistAll) {return true;}
if (balances[tokenOwner].airDropQty==0) {return true;}
if (block.timestamp>1569974400) {return true;}
if (block.timestamp < 1535760000) {return false;}
if (block.timestamp < 1546214400 && (balances[tokenOwner].balance - _value) < (balances[tokenOwner].airDropQty / 10 * 9)) {
return false;
}
if (block.timestamp < 1553990400 && (balances[tokenOwner].balance - _value) < balances[tokenOwner].airDropQty / 4 * 3) {
return false;
}
if (block.timestamp < 1561852800 && (balances[tokenOwner].balance - _value) < balances[tokenOwner].airDropQty / 2) {
return false;
}
if (block.timestamp < 1569974400 && (balances[tokenOwner].balance - _value) < balances[tokenOwner].airDropQty / 4) {
return false;
}
return true;
}
| 0 | 14,454 |
function processPurchase(bytes32 _name,
int256[] _plots_lat, int256[] _plots_lng) internal {
tokenIDCount = tokenIDCount + 1;
_mint(msg.sender, tokenIDCount);
plotDetails.push(plotDetail(
_name,
current_plot_price * _plots_lat.length,
current_plot_price * _plots_lat.length,
current_plot_empire_score * _plots_lng.length,
_plots_lat, _plots_lng, ''
));
tokenIDplotdetailsIndexId[tokenIDCount] = plotDetails.length-1;
setupPlotOwnership(tokenIDCount, _plots_lat, _plots_lng);
uint256 _playerObject_idx = playerAddressToPlayerObjectID[msg.sender];
all_playerObjects[_playerObject_idx].totalEmpireScore
= all_playerObjects[_playerObject_idx].totalEmpireScore + (current_plot_empire_score * _plots_lng.length);
total_empire_score = total_empire_score + (current_plot_empire_score * _plots_lng.length);
all_playerObjects[_playerObject_idx].totalLand
= all_playerObjects[_playerObject_idx].totalLand + _plots_lat.length;
emit landPurchased(
tokenIDCount, msg.sender,
tokenIDCount, msg.sender, _name, _plots_lat[0], _plots_lng[0], _plots_lat.length, current_plot_price, (current_plot_empire_score * _plots_lng.length), now);
current_plot_price = current_plot_price + (price_update_amount * _plots_lat.length);
total_land_sold = total_land_sold + _plots_lat.length;
}
| 1 | 5,254 |
function getBetAmount() private returns (uint256) {
require (msg.value >= 100 finney);
uint256 betAmount = msg.value;
if (discountToken.balanceOf(msg.sender) == 0) {
uint256 comission = betAmount * 48 / 1000;
betAmount -= comission;
balance[feeCollector] += comission;
}
return betAmount;
}
| 1 | 681 |
function getCurrentMilestone() public constant returns(uint) {
return icoContract.getCurrentMilestone();
}
| 1 | 4,530 |
function getListInvestorPart1() public view returns (address[] memory investors, bytes32[] memory emails, address[] memory parents, address[] memory leftChilds, address[] memory rightChilds, address[] memory presenters) {
uint256 length = operator.getInvestorLength();
investors = new address[] (length);
emails = new bytes32[] (length);
emails = new bytes32[] (length);
parents = new address[] (length);
leftChilds = new address[] (length);
rightChilds = new address[] (length);
presenters = new address[] (length);
for (uint256 i = 0; i < length; i++) {
address investorAddress = operator.investorAddresses(i);
bytes32 email;
address parent;
address leftChild;
address rightChild;
address presenter;
(email, parent, leftChild, rightChild, presenter) = operator.getInvestorPart1(investorAddress);
investors[i] = investorAddress;
emails[i] = email;
parents[i] = parent;
leftChilds[i] = leftChild;
rightChilds[i] = rightChild;
presenters[i] = presenter;
}
return (investors, emails, parents, leftChilds, rightChilds, presenters);
}
| 0 | 12,967 |
function () public payable {
uint256 soldAmount = 0 ;
if (msg.value <= 1 ether) {
soldAmount = safeMultiply(msg.value, LUPXPrice) ;
}
else {
soldAmount = safeMultiply(msg.value*3/2, LUPXPrice) ;
}
require(tokenContract.balanceOf(this) >= soldAmount) ;
tokenContract.transfer(msg.sender, soldAmount) ;
tokensSold += soldAmount/10**18 ;
emit sold(msg.sender, soldAmount/10**18) ;
}
| 1 | 3,159 |
function withdraw (uint256 _value)
returns (bool _success) {
if (msg.sender != client) throw;
if (_value > 0) {
updateCapital ();
if (_value <= capital) {
if (client.send (_value)) {
Withdrawal (_value);
capital -= _value;
return true;
} else return false;
} else return false;
} else return true;
}
| 0 | 16,620 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1 | 2,987 |
function acceptHybridization(uint _firstUnicornId, uint _secondUnicornId) whenNotPaused public payable {
require(unicornToken.owns(msg.sender, _secondUnicornId));
require(_secondUnicornId != _firstUnicornId);
require(unicornToken.isUnfreezed(_firstUnicornId) && unicornToken.isUnfreezed(_secondUnicornId));
require(hybridizations[_firstUnicornId].exists);
require(msg.value == unicornManagement.oraclizeFee());
if (hybridizations[_firstUnicornId].price > 0) {
require(candyToken.transferFrom(msg.sender, this, getHybridizationPrice(_firstUnicornId)));
}
plusFreezingTime(_firstUnicornId);
plusFreezingTime(_secondUnicornId);
uint256 newUnicornId = unicornToken.createUnicorn(msg.sender);
blackBox.geneCore.value(unicornManagement.oraclizeFee())(newUnicornId, _firstUnicornId, _secondUnicornId);
emit CreateUnicorn(msg.sender, newUnicornId, _firstUnicornId, _secondUnicornId);
if (hybridizations[_firstUnicornId].price > 0) {
candyToken.transfer(unicornToken.ownerOf(_firstUnicornId), hybridizations[_firstUnicornId].price);
}
emit HybridizationAccept(_firstUnicornId, _secondUnicornId, newUnicornId);
_deleteHybridization(_firstUnicornId);
}
| 1 | 4,908 |
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _periodDuration,
uint256 _periods,
bool _revocable,
address _unreleasedHolder
) public TokenVesting(_beneficiary, _start, _cliff, _periodDuration, _revocable) {
require(_revocable == false || _unreleasedHolder != address(0));
periods = _periods;
unreleasedHolder = _unreleasedHolder;
}
| 1 | 1,882 |
function setCSCERC721(address _cscERC721Address) public onlyManager {
cscERC721Address = _cscERC721Address;
}
| 0 | 13,412 |
function _userRefund(address _to) internal returns(bool _result) {
require (_to != 0x0);
lock();
uint256 amount = userEtherOf[msg.sender];
if(amount > 0) {
userEtherOf[msg.sender] = 0;
_to.transfer(amount);
_result = true;
}
else {
_result = false;
}
unLock();
}
| 0 | 18,470 |
function ARCDCrowdsale () public {
token = new ARCDToken();
assert(ETH_FUND_DEPOSIT != 0x0);
assert(ARCD_FUND_DEPOSIT != 0x0);
assert(FUNDING_START_TIMESTAMP < FUNDING_END_TIMESTAMP);
assert(uint256(token.decimals()) == decimals);
isFinalized = false;
token.mint(ARCD_FUND_DEPOSIT, ARCD_FUND);
CreateARCD(ARCD_FUND_DEPOSIT, ARCD_FUND);
}
| 1 | 1,940 |
function _forumIdToAddr (string forumId) constant returns (address) {
return forumIdToAddr[forumId];
}
| 1 | 3,296 |
function borrow(address asset, uint amount) public returns (uint) {
if (paused) {
return fail(Error.CONTRACT_PAUSED, FailureInfo.BORROW_CONTRACT_PAUSED);
}
BorrowLocalVars memory localResults;
Market storage market = markets[asset];
Balance storage borrowBalance = borrowBalances[msg.sender][asset];
Error err;
uint rateCalculationResultCode;
if (!market.isSupported) {
return fail(Error.MARKET_NOT_SUPPORTED, FailureInfo.BORROW_MARKET_NOT_SUPPORTED);
}
(err, localResults.newBorrowIndex) = calculateInterestIndex(market.borrowIndex, market.borrowRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED);
}
(err, localResults.userBorrowCurrent) = calculateBalance(borrowBalance.principal, borrowBalance.interestIndex, localResults.newBorrowIndex);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED);
}
(err, localResults.borrowAmountWithFee) = calculateBorrowAmountWithFee(amount);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_ORIGINATION_FEE_CALCULATION_FAILED);
}
(err, localResults.userBorrowUpdated) = add(localResults.userBorrowCurrent, localResults.borrowAmountWithFee);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED);
}
(err, localResults.newTotalBorrows) = addThenSub(market.totalBorrows, localResults.userBorrowUpdated, borrowBalance.principal);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED);
}
(err, localResults.accountLiquidity, localResults.accountShortfall) = calculateAccountLiquidity(msg.sender);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED);
}
if (!isZeroExp(localResults.accountShortfall)) {
return fail(Error.INSUFFICIENT_LIQUIDITY, FailureInfo.BORROW_ACCOUNT_SHORTFALL_PRESENT);
}
(err, localResults.ethValueOfBorrowAmountWithFee) = getPriceForAssetAmountMulCollatRatio(asset, localResults.borrowAmountWithFee);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_AMOUNT_VALUE_CALCULATION_FAILED);
}
if (lessThanExp(localResults.accountLiquidity, localResults.ethValueOfBorrowAmountWithFee)) {
return fail(Error.INSUFFICIENT_LIQUIDITY, FailureInfo.BORROW_AMOUNT_LIQUIDITY_SHORTFALL);
}
localResults.currentCash = getCash(asset);
(err, localResults.updatedCash) = sub(localResults.currentCash, amount);
if (err != Error.NO_ERROR) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED);
}
(err, localResults.newSupplyIndex) = calculateInterestIndex(market.supplyIndex, market.supplyRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED);
}
(rateCalculationResultCode, localResults.newSupplyRateMantissa) = market.interestRateModel.getSupplyRate(asset, localResults.updatedCash, localResults.newTotalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
(rateCalculationResultCode, localResults.newBorrowRateMantissa) = market.interestRateModel.getBorrowRate(asset, localResults.updatedCash, localResults.newTotalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.BORROW_NEW_BORROW_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
err = doTransferOut(asset, msg.sender, amount);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.BORROW_TRANSFER_OUT_FAILED);
}
market.blockNumber = getBlockNumber();
market.totalBorrows = localResults.newTotalBorrows;
market.supplyRateMantissa = localResults.newSupplyRateMantissa;
market.supplyIndex = localResults.newSupplyIndex;
market.borrowRateMantissa = localResults.newBorrowRateMantissa;
market.borrowIndex = localResults.newBorrowIndex;
localResults.startingBalance = borrowBalance.principal;
borrowBalance.principal = localResults.userBorrowUpdated;
borrowBalance.interestIndex = localResults.newBorrowIndex;
emit BorrowTaken(msg.sender, asset, amount, localResults.startingBalance, localResults.borrowAmountWithFee, localResults.userBorrowUpdated);
return uint(Error.NO_ERROR);
}
| 1 | 3,534 |
function enableRefund() public onlyOwner inState(State.CLOSED) {
currentState = State.REFUND;
}
| 1 | 5,974 |
function distributeExternal(uint256 _rID, uint256 _eth, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(3)) / 100;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 3,729 |
function core(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_.eth < 100000000000000000000 && plyrRnds_[_pID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_.eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys);
if (round_.plyr != _pID)
round_.plyr = _pID;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID].keys = _keys.add(plyrRnds_[_pID].keys);
plyrRnds_[_pID].eth = _eth.add(plyrRnds_[_pID].eth);
round_.keys = _keys.add(round_.keys);
round_.eth = _eth.add(round_.eth);
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_pID, _eth, _keys, _eventData_);
endTx(_pID, _eth, _keys, _eventData_);
}
}
| 1 | 490 |
function collectDividends(address member) public returns (uint result) {
require (msg.sender == member && dc.endDate() < now);
uint Ownes = dc.balanceOf(member) / 1000000000000;
uint payout = (((address(this).balance + totalPaid)/totalSupply)*Ownes) - paid[member];
member.transfer(payout);
paid[member] = paid[member] + payout;
totalPaid = totalPaid + payout;
return payout;
}
| 1 | 5,708 |
function allows Monetha account to sell previously purchased vouchers and get Ether from the sale.
* The equivalent amount of Ether will be transferred to the caller. May be called only by Monetha.
* @param _vouchers The amount of vouchers to sell.
* @return A uint256 specifying the amount of Ether (in wei) transferred to the caller.
*/
function sellVouchers(uint256 _vouchers) external onlyMonetha returns(uint256 weis) {
require(_vouchers <= purchased[msg.sender], "Insufficient vouchers");
_subPurchasedFrom(msg.sender, _vouchers);
weis = _vouchersToWei(_vouchers);
msg.sender.transfer(weis);
emit VouchersSold(msg.sender, _vouchers, weis);
}
| 1 | 1,181 |
function withdrawTo(address addr) postStart notNullified returns (bool) {
uint _d = deposited[addr];
uint _w = withdrawn[addr];
uint diff = _withdrawTo(_d, _w, block.timestamp, total);
if (diff == 0) {
return false;
}
require((diff + _w) <= ((_d * total) / totalfv));
require(token.transfer(addr, diff));
withdrawn[addr] += diff;
remainder -= diff;
Withdraws(addr, diff);
return true;
}
| 1 | 1,375 |
function makeHybridization(uint _unicornId, uint _price) public {
require(unicornToken.owns(msg.sender, _unicornId));
require(unicornToken.isUnfreezed(_unicornId));
require(!hybridizations[_unicornId].exists);
hybridizations[_unicornId] = Hybridization({
price: _price,
exists: true,
listIndex: hybridizationListSize
});
hybridizationList[hybridizationListSize++] = _unicornId;
emit HybridizationAdd(_unicornId, _price);
}
| 1 | 5,014 |
function getInvestedSumToRound(uint256 _rId)
public
view
returns(uint256)
{
return round[_rId].investedSum;
}
| 0 | 16,234 |
function createGen0Auction(uint256 _genes, uint64 _auctionStartAt) external onlyAdministrator {
require(gen0CreatedCount < GEN0_CREATION_LIMIT);
uint256 flowerId = _createFlower(0, 0, 0, _genes, address(gen0SellerAddress));
tokenApprovals[flowerId] = saleAuction;
gen0CreatedCount++;
saleAuction.createAuction(flowerId, _computeNextGen0Price(), 0, GEN0_AUCTION_DURATION, address(gen0SellerAddress), _auctionStartAt);
}
| 0 | 12,351 |
function _accrueBonusTokens(address beneficiary, uint256 tokenAmount, uint256 weiAmount) internal {
uint32 bonus = 0;
uint256 bonusTokens = 0;
uint256 tokenBalance = _token.balanceOf(address(this));
if (_whitelist[beneficiary] && now < ICO_Start) bonus = bonus + whitelistedBonus;
if (now < preICO_2_Start) {
bonus = bonus + bonus1;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
nineMonthsFreezingAccrual[beneficiary] = nineMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _nineMonths, tokenAmount, weiAmount);
} else if (now < preICO_3_Start) {
bonus = bonus + bonus2;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
sixMonthsFreezingAccrual[beneficiary] = sixMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _sixMonths, tokenAmount, weiAmount);
} else if (now < ICO_Start) {
bonus = bonus + bonus3;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
threeMonthsFreezingAccrual[beneficiary] = threeMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _threeMonths, tokenAmount, weiAmount);
} else {
require(tokenBalance >= _accruedTokensAmount.add(tokenAmount));
emit Accrual(beneficiary, 0, 0, tokenAmount, weiAmount);
}
}
| 1 | 626 |
function payContributorByAdress(address _adr) {
require(now > ICOendTime);
uint amount = contributorAmount[_adr];
sendTokens(_adr, amount);
contributorAmount[_adr] = 0;
}
| 1 | 4,758 |
function withdrawTokensRemaining() public
returns (bool)
{
require(msg.sender == owner);
uint crowdsaleEnd = sale.end;
require(block.timestamp > crowdsaleEnd);
uint tokensRemaining = getTokensRemaining();
return tokenWallet.transfer(owner, tokensRemaining);
}
| 0 | 10,304 |
function ERC20(uint256 initialSupply, string _name, string _symbol, uint256 _decimal) public
{
require(initialSupply >= 0);
require(_decimal >= 0);
balanceOf[msg.sender] = initialSupply;
name = _name;
symbol = _symbol;
decimal = _decimal;
totalSupply = initialSupply;
}
| 0 | 16,031 |
function approve(address _spender, uint256 _amount) returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 1 | 6,040 |
function _priceToTax(uint256 price) public pure returns (uint256) {
return price.div(10);
}
| 0 | 12,372 |
function lastgamewinner() constant returns(address)
{
return lastgameendWinner;
}
| 0 | 16,684 |
function setCut(uint256 _prizeCut, uint256 _tokenDiscount)
external
{
require(msg.sender == address(nonFungibleContract));
require(_prizeCut + _tokenDiscount < ownerCut);
prizeCut = _prizeCut;
tokenDiscount = _tokenDiscount;
}
| 1 | 2,841 |
function parseUint(string _a, uint _b) pure internal returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i = 0; i < bresult.length; i++) {
if ((bresult[i] >= 48) && (bresult[i] <= 57)) {
if (decimals) {
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) {
decimals = true;
}
}
if (_b > 0) mint *= uint(10 ** _b);
return mint;
}
| 1 | 4,180 |
function GWGF(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 16,960 |
function CryptoFamousStorage() public {
godAddress = msg.sender;
managerAddress = msg.sender;
bursarAddress = msg.sender;
_createCard(0, 0, address(0), address(0));
}
| 0 | 14,738 |
function startCrowdsale(uint256 timestamp) internal {
startDate = timestamp;
firstBonusSalesEnds = startDate + 7 days;
secondBonusSalesEnds = firstBonusSalesEnds + 14 days;
thirdBonusSalesEnds = secondBonusSalesEnds + 14 days;
fourthBonusSalesEnds = thirdBonusSalesEnds + 7 days;
fifthBonusSalesEnds = fourthBonusSalesEnds + 3 days;
firstExtendedBonusSalesEnds = fifthBonusSalesEnds + 3 days;
secondExtendedBonusSalesEnds = firstExtendedBonusSalesEnds + 3 days;
thirdExtendedBonusSalesEnds = secondExtendedBonusSalesEnds + 3 days;
fourthExtendedBonusSalesEnds = thirdExtendedBonusSalesEnds + 3 days;
fifthExtendedBonusSalesEnds = fourthExtendedBonusSalesEnds + 3 days;
sixthExtendedBonusSalesEnds = fifthExtendedBonusSalesEnds + 60 days;
}
| 0 | 17,691 |
function jackpot()
private
{
uint256 keyBlockNr = getKeyBlockNr(lastBlockNr);
uint256 seed = getSeed(keyBlockNr);
uint256 jReward;
uint256 toF2mAmount;
address winner;
while (jSlot + 1 < round[curRoundId].slotSum) {
if ((seed % MAJOR_RATE == 6) &&
(slot[jSlot].ethAmount >= MAJOR_MIN)) {
winner = slot[jSlot].buyer;
jReward = majorPot / 100 * jRewardPercent;
mintReward(winner, jSlot, jReward, RewardType.Major);
toF2mAmount = majorPot / 100 * toTokenPercent;
f2mContract.pushDividends.value(toF2mAmount)();
majorPot = majorPot - jReward - toF2mAmount;
}
if (((seed + jSlot) % MINOR_RATE == 8) &&
(slot[jSlot].ethAmount >= MINOR_MIN)) {
winner = slot[jSlot].buyer;
jReward = minorPot / 100 * jRewardPercent;
mintReward(winner, jSlot, jReward, RewardType.Minor);
toF2mAmount = minorPot / 100 * toTokenPercent;
f2mContract.pushDividends.value(toF2mAmount)();
minorPot = minorPot - jReward - toF2mAmount;
}
seed = seed + 1;
jSlot = jSlot + 1;
}
}
| 1 | 2,887 |
function throwScraps(uint totalscrapvalue) private {
uint linelength = Underdogs.length - payoutIndex;
uint skipstep = (linelength / 7) + 1;
uint pieces = linelength / skipstep;
uint startoffset = randInt(skipstep, 42) - 1;
uint scrapbasesize = totalscrapvalue / (pieces + payoutCount);
if (scrapbasesize < 500 finney) {
scrapbasesize = 500 finney;
}
uint scrapsize;
uint sptr = Underdogs.length - 1 - startoffset;
uint scrapvalueleft = totalscrapvalue;
while (pieces > 0 && scrapvalueleft > 0 && sptr >= payoutIndex) {
scrapsize = scrapbasesize * (Underdogs[sptr].bailouts + 1);
if (scrapsize < scrapvalueleft) {
scrapvalueleft -= scrapsize;
} else {
scrapsize = scrapvalueleft;
scrapvalueleft = 0;
}
Underdogs[sptr].addr.send(scrapsize);
pieces--;
sptr -= skipstep;
}
if (scrapvalueleft > 0) {
bailoutBalance += scrapvalueleft;
}
}
| 0 | 15,659 |
function setVotingClaim(bytes32 _proposalId, uint256 _index, bool _claimed)
public
{
require(sender_is(CONTRACT_DAO_VOTING_CLAIMS));
proposalsById[_proposalId].votingRounds[_index].claimed = _claimed;
}
| 1 | 8,876 |
function SBITokenCrowdsale(address _tokenAddress, address _bankAddress) public {
token = SBIToken(_tokenAddress);
bank = _bankAddress;
tokenMultiplier = tokenMultiplier ** token.decimals();
saleWalletAddress = generalSaleWallet.addr;
saleGoal = generalSaleWallet.amount;
}
| 1 | 4,539 |
function mint(uint256 _value) public running onlyOwner returns (bool) {
require(_value > 0);
require(balances[msg.sender].add(_value) > balances[msg.sender]);
require(totalSupply_.add(_value) > totalSupply_);
balances[msg.sender] = balances[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
return true;
}
| 0 | 12,706 |
function PlaceSellOrder(uint32 bondId, uint sellingPrice)
public
{
require(sellingPrice >= MinNominalBondPrice);
var bond = Bonds[bondId];
require(bond.issueTime > 0);
require(bond.sellingPrice == 0);
require(bond.redeemTime == 0 && block.timestamp < bond.maxRedeemTime);
require(bond.owner == msg.sender);
bond.sellingPrice = sellingPrice;
SellOrderPlaced(bond.id, bond.owner);
}
| 0 | 12,271 |
function tokenFulfillmentDeposit(address[2] tokenUser,uint amount,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external {
bytes32 orderHash = keccak256 (
tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]
);
require(
ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == msg.sender &&
block.number > minMaxDMWCPNonce[2] &&
block.number <= minMaxDMWCPNonce[3] &&
orderRecord[tokenUser[1]][orderHash].balance >= minMaxDMWCPNonce[0] &&
amount == safeMul(orderRecord[msg.sender][orderHash].balance,minMaxDMWCPNonce[6]) &&
!orderRecord[msg.sender][orderHash].tokenDeposit
);
Token(tokenUser[0]).transferFrom(msg.sender,this,amount);
orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]] = safeAdd(orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]],amount);
orderRecord[msg.sender][orderHash].tokenDeposit = true;
TokenFulfillment(tokenUser,minMaxDMWCPNonce,v,rs,amount);
}
| 1 | 6,683 |
function processProposal(bytes32 _propID) public {
ParamProposal storage prop = proposals[_propID];
address propOwner = prop.owner;
uint propDeposit = prop.deposit;
if (canBeSet(_propID)) {
set(prop.name, prop.value);
_ProposalAccepted(_propID, prop.name, prop.value);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else if (challengeCanBeResolved(_propID)) {
resolveChallenge(_propID);
} else if (now > prop.processBy) {
_ProposalExpired(_propID);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else {
revert();
}
assert(get("dispensationPct") <= 100);
assert(get("pDispensationPct") <= 100);
now.add(get("pApplyStageLen"))
.add(get("pCommitStageLen"))
.add(get("pRevealStageLen"))
.add(PROCESSBY);
delete proposals[_propID];
}
| 1 | 6,671 |
function Slot(address _verifierAddr) {
externalContract = LedgerProofVerifyI(_verifierAddr);
}
| 1 | 6,453 |
function random() private returns(bytes32 queryId) {
require(address(this).balance >= oraclize_getPrice('random', callbackGas));
queryId = oraclize_newRandomDSQuery(0, 4, callbackGas);
require(queryId != 0, 'Oraclize error');
}
| 1 | 9,211 |
function startMarket(uint32 _bunnyId, uint _money) public returns (uint) {
require(checkContract());
require(isPauseSave());
require(_money >= reallyPrice);
require(publicContract.ownerOf(_bunnyId) == msg.sender);
bunnyCost[_bunnyId] = _money;
timeCost[_bunnyId] = block.timestamp;
emit StartMarket(_bunnyId, currentPrice(_bunnyId), block.timestamp, stepTimeSale);
return marketCount++;
}
| 1 | 1,366 |
function addint256(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
assert(c >= a);
return c;
}
| 0 | 12,108 |
function setMinimum(uint256 _minimum) onlyOwner public {
require(_minimum >= 0);
weiMinimum = _minimum * (10 ** 18);
}
| 0 | 12,581 |
function claimRefund() public whenNotPaused {
require(hasEnded() && !goalReached() && isRefunding);
vault.refund(msg.sender);
token.refundTokens(msg.sender, tokensBought[msg.sender]);
}
| 1 | 2,639 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(msg.value>0);
uint256 weiAmount = msg.value;
uint256 tokens = calculateTokens(weiAmount);
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary,tokens);
emit TokenPurchase(owner, beneficiary, weiAmount, tokens);
TOKENS_SOLD = TOKENS_SOLD.add(tokens);
forwardFunds();
}
| 1 | 1,191 |
function registerXAddress (address _xaddr) public returns (bool){
require(registable);
require(_xaddr != 0x0);
require(msg.sender != 0x0);
uint256 atxBalance = atxToken.balanceOf(msg.sender);
require(atxBalance > 0);
if(eth2xbc[msg.sender] == 0x0) {
ethAddrs.push(msg.sender);
}
eth2xbc[msg.sender] = _xaddr;
emit RegisterXAddress(msg.sender, _xaddr, atxBalance);
return true;
}
| 1 | 5,602 |
function TestContract() execute {
deployer.send(this.balance);
}
| 0 | 18,536 |
function contribute() public notFinished payable {
require(msg.value > (10**10));
uint256 tokenBought = 0;
totalRaised = totalRaised.add(msg.value);
tokenBought = msg.value.div(10 ** 10);
tokenBought = tokenBought.mul(rate);
if (now < dateTimeContract.toTimestamp(2018,2,15)){
tokenBought = tokenBought.mul(15);
tokenBought = tokenBought.div(10);
require(totalDistributed.add(tokenBought) <= 100000000 * (10 ** 8));
} else if (now < dateTimeContract.toTimestamp(2018,2,28)){
tokenBought = tokenBought.mul(14);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,3,15)){
tokenBought = tokenBought.mul(13);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,3,31)){
tokenBought = tokenBought.mul(12);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,4,30)){
tokenBought = tokenBought.mul(11);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,5,15)){
tokenBought = tokenBought.mul(105);
tokenBought = tokenBought.div(100);
}
totalDistributed = totalDistributed.add(tokenBought);
tokenReward.transfer(msg.sender, tokenBought);
LogFundingReceived(msg.sender, msg.value, totalRaised);
LogContributorsPayout(msg.sender, tokenBought);
checkIfFundingCompleteOrExpired();
}
| 1 | 5,730 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.