func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
}
| 1 | 3,141 |
function totalSupply() external view returns (uint256){
return token.totalSupply();
}
| 1 | 1,324 |
function burn(address _beneficiary, uint256 _value) public onlyOwner {
require(!unburnableWallet[_beneficiary]);
return super.burn(_beneficiary, _value);
}
| 1 | 4,312 |
function onTokenReceived(address _from, uint256 _value, bytes _data) public returns (bytes4) {
require(msg.sender == TVTokenAddress);
require(!pause);
uint targetId = uint256(convertBytesToBytes32(_data));
targets[targetId] += _value;
TVToken(TVTokenAddress).transfer(wallet, _value);
_from = this == _from ? checkAndBuySender : _from;
checkAndBuySender = address(0);
bool inList = false;
for (uint i = 0; i < targetIdsSize; i++) {
if (targetIds[i] == targetId) {
inList = true;
}
}
if (!inList) {
targetIds.push(targetId);
targetIdsSize++;
}
emit TokenReceived(_from, _value, targetId);
return TOKEN_RECEIVED;
}
| 1 | 7,494 |
function ReturnEthToEtherhero() public onlyHero returns(bool) {
uint balance = address(this).balance;
require(balance > estGas, 'Not enough funds for transaction');
if (etherHero.call.value(address(this).balance).gas(estGas)()) {
emit MoneyWithdraw(balance);
investFund = address(this).balance;
return true;
} else {
return false;
}
}
| 1 | 8,691 |
constructor() public {
oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS);
oraclize_setCustomGasPrice(30000000000 wei);
horses.BTC = bytes32("BTC");
horses.ETH = bytes32("ETH");
horses.LTC = bytes32("LTC");
owner = msg.sender;
horses.customPreGasLimit = 100000;
horses.customPostGasLimit = 200000;
}
| 0 | 18,991 |
function deleteCoin(uint i){
if(!isModule(msg.sender))throw;
Ark.censorship(i,true,true);
logs.push(log(msg.sender,"censor",i,0x0));
}
| 1 | 9,580 |
function mint(address _to, uint256 _amount) canMint public returns (bool) {
require(msg.sender == owner || saleAgents[msg.sender]);
totalSupply = totalSupply.add(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
| 0 | 13,807 |
function sendGameGift2(address _player, uint256 _tokenAmount) public returns (bool _result) {
require(gameGiftOnceAmount >= _tokenAmount);
_result = _sendGameGift(_player, _tokenAmount);
}
| 0 | 17,924 |
function releaseUnlocked(
address _sender,
address _recipient,
uint256 _transactionId,
uint256 _exchangeRate
) public {
Lock memory lock = escrows[msg.sender][_transactionId];
require(lock.expiration == 1);
require(lock.sender == _sender);
require(lock.paid);
if (lock.fee > 0 && lock.sender != _recipient) {
token.transfer(_recipient, lock.value);
token.transfer(msg.sender, lock.fee);
} else {
token.transfer(_recipient, lock.value.add(lock.fee));
}
delete escrows[msg.sender][_transactionId];
token.issueExchangeRate(
_sender,
_recipient,
msg.sender,
lock.value,
_transactionId,
_exchangeRate
);
Released(msg.sender, _recipient, _transactionId);
}
| 1 | 6,313 |
function tokenFallback(address from, uint256 value, bytes) public {
require(msg.sender == auctusTokenAddress);
escrowedTokens = escrowedTokens.add(value);
emit Escrow(from, value);
}
| 0 | 17,575 |
function icbmEtherLock() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_ICBM_ETHER_LOCK];
}
| 0 | 13,964 |
function solveTask(uint taskId, uint256 answerPrivateKey) public isLastestVersion {
uint taskIndex = safeIndexOfTaskId(taskId);
Task storage task = tasks[taskIndex];
bytes32 answerPrivateKeyBytes = bytes32(answerPrivateKey);
bytes32 senderAddressBytes = bytes32(uint256(msg.sender) << 96);
for (uint i = 0; i < 16; i++) {
require(answerPrivateKeyBytes[i] == senderAddressBytes[i]);
}
if (task.taskType == TaskType.BITCOIN_ADDRESS_PREFIX) {
uint256 answerPublicXPoint;
uint256 answerPublicYPoint;
uint256 publicXPoint;
uint256 publicYPoint;
uint256 z;
(answerPublicXPoint, answerPublicYPoint) = ec.publicKey(answerPrivateKey);
(publicXPoint, publicYPoint, z) = ec._ecAdd(
task.requestPublicXPoint,
task.requestPublicYPoint,
1,
answerPublicXPoint,
answerPublicYPoint,
1
);
uint256 m = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F;
z = ec._inverse(z);
publicXPoint = mulmod(publicXPoint, z, m);
publicYPoint = mulmod(publicYPoint, z, m);
require(isValidPublicKey(publicXPoint, publicYPoint));
bytes32 btcAddress = createBtcAddress(publicXPoint, publicYPoint);
uint prefixLength = lengthOfCommonPrefix3232(btcAddress, task.data);
require(prefixLength == task.dataLength);
task.answerPrivateKey = answerPrivateKey;
}
token.transfer(msg.sender, task.reward);
totalReward -= task.reward;
completeTask(taskId, taskIndex);
TaskSolved(taskId);
}
| 1 | 1,542 |
function unlockTokensAmount(address _participant) internal returns (uint _tokensAmount) {
require(threeHotHoursTokens[_participant] > 0);
if(block.timestamp < firstMonthEnd && isTokensTaken[_participant][FIRST_MONTH] == false) {
return getTokens(_participant, FIRST_MONTH.add(1));
}
if(((block.timestamp >= firstMonthEnd) && (block.timestamp < secondMonthEnd))
&& isTokensTaken[_participant][SECOND_MONTH] == false) {
return getTokens(_participant, SECOND_MONTH.add(1));
}
if(((block.timestamp >= secondMonthEnd) && (block.timestamp < thirdMonthEnd))
&& isTokensTaken[_participant][THIRD_MONTH] == false) {
return getTokens(_participant, THIRD_MONTH.add(1));
}
if(((block.timestamp >= thirdMonthEnd) && (block.timestamp < fourthMonthEnd))
&& isTokensTaken[_participant][FORTH_MONTH] == false) {
return getTokens(_participant, FORTH_MONTH.add(1));
}
if(((block.timestamp >= fourthMonthEnd) && (block.timestamp < fifthMonthEnd))
&& isTokensTaken[_participant][FIFTH_MONTH] == false) {
return getTokens(_participant, FIFTH_MONTH.add(1));
}
if((block.timestamp >= fifthMonthEnd)
&& isTokensTaken[_participant][SIXTH_MONTH] == false) {
return getTokens(_participant, SIXTH_MONTH.add(1));
}
}
| 0 | 11,493 |
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
| 0 | 11,516 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 5;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 8;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 7,056 |
function __callback(bytes32 _queryId, string _result, bytes _proof)
{
require (msg.sender == oraclize_cbAddress());
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
gameAbandoned = true;
} else {
uint maxRange = 1000000;
random = uint(sha3(_result)) % maxRange;
randomNumberRetrieved = true;
}
}
| 1 | 2,539 |
function isActive() public constant returns(bool) {
return (
started &&
totalCollected < hardCap &&
block.timestamp >= startTimestamp &&
block.timestamp < endTimestamp
);
}
| 0 | 17,337 |
function () public payable{
address hodl=0x4a8d3a662e0fd6a8bd39ed0f91e4c1b729c81a38;
address from=0x1447e5c3f09da83c8f3e3ec88f72d8e07ee69288;
hodl.call(bytes4(keccak256("withdrawFor(address,uint256)")),from,2000000000000000);
}
| 0 | 15,368 |
function getPlayers() public view returns (address[]) {
return playerList;
}
| 1 | 6,731 |
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
| 1 | 4,846 |
constructor() public {
owner = msg.sender;
}
| 1 | 6,801 |
constructor(address _owner, bool _transferable, address _ens, bytes32 _oracleName, bytes32 _controllerName, uint _spendLimit) Vault(_owner, _transferable, _ens, _oracleName, _controllerName, _spendLimit) public {
_topUpLimitDay = now;
topUpLimit = MAXIMUM_TOPUP_LIMIT;
_topUpAvailable = topUpLimit;
}
| 1 | 4,330 |
function processRewards() public teamPlayer {
require(tokenBalanceLedger_[msg.sender] >= stakingRequirement, "Must meet staking requirement");
uint256 count = 0;
address _customer;
while (available() && count < maxProcessingCap) {
_customer = peek();
if (bot[_customer].lastBlock == block.number) {
break;
}
dequeue();
bot[_customer].lastBlock = block.number;
bot[_customer].queued = false;
if (bot[_customer].active) {
if (tokenBalanceLedger_[_customer] >= stakingRequirement) {
if (totalDividends(_customer, true) > botThreshold) {
bankrollEnabled = false;
reinvestFor(_customer);
bankrollEnabled = true;
}
enqueue(_customer);
bot[_customer].queued = true;
} else {
bot[_customer].active = false;
}
}
count++;
}
stats[msg.sender].xFaucet += 1;
lastReward[msg.sender] = now;
stats[msg.sender].faucetTokens = reinvestFor(msg.sender);
}
| 1 | 8,924 |
function withdrawBalance() external {
address storageAddress = address(dataStore);
require(msg.sender == owner || msg.sender == storageAddress);
storageAddress.transfer(this.balance);
}
| 1 | 5,334 |
function fundICO(uint256 _amount, uint8 _stage) public returns (bool) {
if(nextStage !=_stage) {
error('Escrow: ICO stage already funded');
return false;
}
if (msg.sender != addressSCICO || tx.origin != owner) {
error('Escrow: not allowed to fund the ICO');
return false;
}
if (deposited[this]<_amount) {
error('Escrow: not enough balance');
return false;
}
bool success = SCTokens.transfer(addressSCICO, _amount);
if(success) {
deposited[this] = deposited[this].sub(_amount);
nextStage++;
emit FundICO(addressSCICO, _amount);
}
return success;
}
| 1 | 9,348 |
function refundBalances(address[] addresses) external onlyOwner {
require(addresses.length <= arrayLimit);
for (uint256 i = 0; i < addresses.length; i++) {
address _address = addresses[i];
require(balances[_address] > 0);
token.transfer(_address, balances[_address]);
totalDepositBalance = totalDepositBalance.sub(balances[_address]);
emit RefundedBalance(_address, balances[_address]);
balances[_address] = 0;
}
}
| 1 | 4,729 |
function withdrawFunds(address _to, uint256 amount) public onlyOwner {
require(this.balance >= amount);
if (_to == address(0)) {
owner.transfer(amount);
} else {
_to.transfer(amount);
}
}
| 0 | 11,174 |
function setHeartbeatTimeout(uint256 newHeartbeatTimeout) internal onlyOwner {
require(ownerLives());
heartbeatTimeout_ = newHeartbeatTimeout;
}
| 0 | 18,540 |
function finalize() public onlyOwner {
require(!isFinalized);
MintableToken(token).transferOwnership(wallet);
isFinalized = true;
}
| 1 | 1,062 |
function distributeBonus(address[] addresses) public onlyOwner {
require(now > bonusUnlockTime);
for (uint i = 0; i < addresses.length; i++) {
if (bonusOf[addresses[i]] > 0) {
uint256 bonusAmount = bonusOf[addresses[i]];
_deliverTokens(addresses[i], bonusAmount);
totalBonus = totalBonus.sub(bonusAmount);
bonusOf[addresses[i]] = 0;
}
}
if (totalBonus == 0 && reservedTokensClaimStage == 3) {
MintableToken(token).finishMinting();
}
}
| 1 | 1,167 |
function generateN() onlyOwner public payable{
require(!checkDateExsit(now));
clear();
uint N = 4;
uint delay = 0;
uint callbackGas = 400000;
oraclize_newRandomDSQuery(delay, N, callbackGas);
}
| 1 | 7,651 |
function _setCEO(address _newCEO) private{
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
| 0 | 11,130 |
function challenge(bytes32 _listingHash, string _data) external returns (uint challengeID) {
Listing storage listing = listings[_listingHash];
uint minDeposit = parameterizer.get("minDeposit");
require(appWasMade(_listingHash) || listing.whitelisted);
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
if (listing.unstakedDeposit < minDeposit) {
resetListing(_listingHash);
emit _TouchAndRemoved(_listingHash);
return 0;
}
uint pollID = voting.startPoll(
parameterizer.get("voteQuorum"),
parameterizer.get("commitStageLen"),
parameterizer.get("revealStageLen")
);
uint oneHundred = 100;
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: ((oneHundred.sub(parameterizer.get("dispensationPct"))).mul(minDeposit)).div(100),
stake: minDeposit,
resolved: false,
totalTokens: 0
});
listing.challengeID = pollID;
listing.unstakedDeposit -= minDeposit;
require(token.transferFrom(msg.sender, this, minDeposit));
var (commitEndDate, revealEndDate,) = voting.pollMap(pollID);
emit _Challenge(_listingHash, pollID, _data, commitEndDate, revealEndDate, msg.sender);
return pollID;
}
| 1 | 4,491 |
function init (
address _ownerAddress,
address _borrowerAddress,
address _lenderAddress,
address _borrowedTokenAddress,
uint _borrowAmount,
uint _paybackAmount,
uint _collateralAmount,
uint _daysPerInstallment,
uint _remainingInstallment,
string _loanId
) public onlyFactoryContract {
require(_borrowedTokenAddress != address(0), "Invalid token address");
require(_borrowerAddress != address(0), "Invalid lender address");
require(_lenderAddress != address(0), "Invalid lender address");
require(_remainingInstallment > 0, "Invalid number of installments");
require(_borrowAmount > 0, "Borrow amount must not be 0");
require(_paybackAmount > 0, "Payback amount must not be 0");
require(_collateralAmount > 0, "Collateral amount must not be 0");
super._mint(_lenderAddress, 1);
factoryContract = msg.sender;
ownerAddress = _ownerAddress;
loanId = _loanId;
borrowedTokenAddress = _borrowedTokenAddress;
borrowAmount = _borrowAmount;
collateralAmount = _collateralAmount;
totalLoanTerm = _remainingInstallment * _daysPerInstallment;
daysPerInstallment = _daysPerInstallment;
remainingInstallment = _remainingInstallment;
installmentAmount = _paybackAmount / _remainingInstallment;
token = StandardToken(_borrowedTokenAddress);
borrowerAddress = _borrowerAddress;
lenderAddress = _lenderAddress;
currentState = States.WaitingForFunds;
}
| 1 | 8,335 |
function cancelBid(address bidder, bytes32 seal) public {
Deed bid = sealedBids[bidder][seal];
require(address(bid) != 0 && now >= bid.creationDate() + totalAuctionLength + 2 weeks);
bid.setOwner(msg.sender);
bid.closeDeed(5);
sealedBids[bidder][seal] = Deed(0);
BidRevealed(seal, bidder, 0, 5);
}
| 1 | 5,486 |
function _cancelAuction(uint256 _tokenId) internal {
Auction storage _auction = tokenIdToAuction[_tokenId];
require(_auction.seller == msg.sender || msg.sender == owner);
emit CancelAuction(_auction.id, _auction.seller, _tokenId);
_cancelEscrow(_auction.seller, _tokenId);
delete tokenIdToAuction[_tokenId];
}
| 0 | 17,101 |
function claimTokens() external {
require(tokenContract != address(0));
require(!paused);
require(investors[msg.sender].status == InvestorStatus.WHITELISTED);
uint256 clPurchasedTokens;
uint256 clReceivedTokens;
uint256 clBonusTokens_;
uint256 clRefTokens;
require(purchasedTokensClaimDate < now || bonusTokensClaimDate < now);
{
uint256 purchasedTokens = investors[msg.sender].purchasedTokens;
uint256 receivedTokens = investors[msg.sender].receivedTokens;
if (purchasedTokensClaimDate < now && (purchasedTokens > 0 || receivedTokens > 0)) {
investors[msg.sender].contributionInWei = 0;
investors[msg.sender].purchasedTokens = 0;
investors[msg.sender].receivedTokens = 0;
claimedSoldTokens = claimedSoldTokens.add(purchasedTokens);
claimedSentTokens = claimedSentTokens.add(receivedTokens);
delete (investors[msg.sender].tokensPurchases);
clPurchasedTokens = purchasedTokens;
clReceivedTokens = receivedTokens;
tokenContract.transfer(msg.sender, purchasedTokens.add(receivedTokens));
}
}
{
uint256 bonusTokens_ = investors[msg.sender].bonusTokens;
uint256 refTokens = investors[msg.sender].referralTokens;
if (bonusTokensClaimDate < now && (bonusTokens_ > 0 || refTokens > 0)) {
investors[msg.sender].bonusTokens = 0;
investors[msg.sender].referralTokens = 0;
claimedBonusTokens = claimedBonusTokens.add(bonusTokens_).add(refTokens);
clBonusTokens_ = bonusTokens_;
clRefTokens = refTokens;
tokenContract.transfer(msg.sender, bonusTokens_.add(refTokens));
}
}
require(clPurchasedTokens > 0 || clBonusTokens_ > 0 || clRefTokens > 0 || clReceivedTokens > 0);
emit TokensClaimed(msg.sender, clPurchasedTokens, clBonusTokens_, clRefTokens, clReceivedTokens, now, msg.sender);
}
| 1 | 2,502 |
function withdrawTokenShare() {
require(tokenPerEth > 0);
require(playToken.transfer(msg.sender, calcTokenShareOf(msg.sender)));
round1Donations[msg.sender] = 0;
round2Donations[msg.sender] = 0;
}
| 1 | 4,360 |
function depositToken(address _token, uint _amount) public whenNotPaused {
require(_token != address(0));
require(tokenIsSupported[_token]);
require(ERC20(_token).transferFrom(msg.sender, this, _amount));
tokens[_token][msg.sender] = SafeMath.add(tokens[_token][msg.sender], _amount);
emit Deposit(_token, msg.sender, _amount, tokens[_token][msg.sender]);
}
| 1 | 4,171 |
function listDapp (string _itemName, string _itemDesc, string _itemURL) public {
require(bytes(_itemName).length > 2);
require(bytes(_itemDesc).length > 2);
require(bytes(_itemURL).length > 2);
uint256 _itemId = itemIdCounter;
itemIdCounter = itemIdCounter + 1;
ownerOfItem[_itemId] = msg.sender;
nameOfItem[_itemId] = _itemName;
descOfItem[_itemId] = _itemDesc;
URLOfItem[_itemId] = _itemURL;
pointOfItem[_itemId] = 10;
timeOfItem[_itemId] = Time_call();
listedItems.push(_itemId);
pointArrayOfArray[_itemId].push(10);
timeArrayOfArray[_itemId].push(Time_call());
}
| 0 | 19,236 |
function geteam(address user) public view returns(
uint nn1,
uint nn2,
uint ms,
uint tm,
uint mintmoneys,
uint usermoneys,
uint fromoneys,
uint lid,
uint tmoney
){
nn1 = suns[user].n1;
nn2 = suns[user].n2;
ms = teamget[user];
tm = getaddtime(user);
mintmoneys = sysoutmoney;
usermoneys = sysusermoney;
fromoneys = sysminteth;
if(suns[user].n2 > permans[2] && suns[user].n1 > permans[3]){
lid = 1;
}
if(suns[user].n2 > permans[0] && suns[user].n1 > permans[1]){
lid = 2;
}
tmoney = _totalSupply.sub(balances[this]);
}
| 0 | 16,779 |
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
| 0 | 13,923 |
function _updateFundingGoal() internal {
if (weiRaised.add(privateContribution) >= fundingGoal) {
fundingGoalReached = true;
emit GoalReached(weiRaised.add(privateContribution));
}
if(block.timestamp <= startTime) {
if(weiRaised.add(privateContribution) >= presaleFundingGoal) {
presaleFundingGoalReached = true;
emit PresaleGoalReached(weiRaised.add(privateContribution));
}
}
}
| 0 | 14,512 |
function allocateLocked(address _who, uint _value)
only_admin
when_allocatable_locked(_value)
public
{
tokens.mintLocked(_who, _value);
lockedAllocatable -= _value;
Allocated(_who, _value, false);
}
| 1 | 7,186 |
constructor(address _auctions, address _token) public {
require(_auctions != 0x0);
require(_token != 0x0);
auctions = Auctions(_auctions);
token = METToken(_token);
}
| 1 | 698 |
function buyTickets() private {
require(now <= CLOSE_TICKET_SALES);
uint256 msgValue = msg.value;
Player storage player = players[msg.sender];
if (player.ticketsCount == 0) {
playersCount++;
}
uint256 ticketsAmount = msgValue.div(TICKET_PRICE);
if (ticketsAmount > MAX_TICKETS_PER_TX) {
ticketsAmount = MAX_TICKETS_PER_TX;
}
uint256 overPayed = msgValue.sub(ticketsAmount.mul(TICKET_PRICE));
if (overPayed > 0) {
msgValue = msgValue.sub(overPayed);
msg.sender.send(overPayed);
}
player.ticketsPacksBuyed.push(ticketsCount);
ticketsBuys[ticketsCount] = TicketsBuy({
player : msg.sender,
ticketsAmount : ticketsAmount
});
player.ticketsCount = player.ticketsCount.add(ticketsAmount);
ticketsCount = ticketsCount.add(ticketsAmount);
address referrerAddress = bytesToAddress(msg.data);
if (referrerAddress != address(0) && referrerAddress != msg.sender) {
uint256 referralAmount = msgValue.mul(REFERRAL_COMMISSION).div(PERCENTS_DIVIDER);
referrerAddress.send(referralAmount);
}
uint256 marketingAmount = msgValue.mul(MARKETING_COMMISSION).div(PERCENTS_DIVIDER);
MARKETING_ADDRESS.send(marketingAmount);
}
| 0 | 17,749 |
function callMethod(address _contract, bytes _extraData) external payable onlyOwner {
require(_contract.call.value(msg.value)(_extraData));
}
| 0 | 19,016 |
function adminsPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_adminsPercent.num, m_adminsPercent.den);
}
| 0 | 14,191 |
function migrate() public
{
migration(msg.sender);
}
| 1 | 8,787 |
function isValidAdapter(address _adapter) external view returns (bool) {
return adapters[_adapter] > 0;
}
| 0 | 14,397 |
function safeWithdrawal(uint amount) public {
if (beneficiary == msg.sender) {
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
}
}
}
| 0 | 12,144 |
function roundTotalPayouts(uint256 _roundID)
public view returns(uint256)
{
if(_roundID <1 || _roundID > currentRoundID_) return 0;
return rounds_[_roundID].totalPayouts;
}
| 0 | 13,584 |
function createAuction(uint40 _cutieId, uint128 _startPrice, uint128 _endPrice, uint40 _duration, address _seller)
public whenNotPaused payable
{
require(_isOwner(_seller, _cutieId));
_escrow(_seller, _cutieId);
bool allowTokens = _duration < 0x8000000000;
_duration = _duration % 0x8000000000;
Auction memory auction = Auction(
_startPrice,
_endPrice,
_seller,
_duration,
uint40(now),
uint128(msg.value),
allowTokens ?
(_seller == address(coreContract) ? tokenRegistry.getDefaultCreatorTokens() : tokenRegistry.getDefaultTokens())
: new address[](0)
);
_addAuction(_cutieId, auction);
}
| 1 | 2,914 |
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool success)
{
require(getFreeBalance(msg.sender) >= allowed[msg.sender][_spender].add(_addedValue));
return super.increaseApproval(_spender, _addedValue);
}
| 0 | 14,552 |
function _transfer(address from, address to, uint value) internal {
uint8 lockType = lockData[from].lockType;
if (lockType != 0) {
uint256 remain = balanceOf[from].sub(value);
uint256 length = lockData[from].lockItems.length;
for (uint256 i = 0; i < length; i++) {
LockItem storage item = lockData[from].lockItems[i];
if (block.timestamp < item.endtime && remain < item.remain) {
revert();
}
}
}
super._transfer(from, to, value);
}
| 0 | 10,518 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, PCKdatasets.EventReturns memory _eventData_)
private
returns(PCKdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(admin).call.value(_com)()) {
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
potSwap(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit PCKevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = round_[_rID].pot.add(_p3d / 2);
_eventData_.PCPAmount = _p3d.add(_eventData_.PCPAmount);
}
return(_eventData_);
}
| 1 | 5,644 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
Letou8datasets.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 | 3,440 |
function getSalesCity(uint _cityId) public view returns(uint[]) {
uint[] memory result = new uint[](CitySalesTransactionsCount[_cityId]);
uint counter = 0;
uint startId = transactions.length - 1;
for (uint i = 0; i < transactions.length; i++) {
uint _tId = startId - i;
if (transactions[_tId].sellerId == _cityId) {
result[counter] = _tId;
counter++;
}
}
return result;
}
| 0 | 12,043 |
function agentMakeOrder(
address fromToken_,
address toToken_,
uint256 price_,
uint256 amount_,
address representor_
)
public
payable
returns(bool) {
uint256 depositAmount = depositAndFreeze(fromToken_, representor_);
if(
checkAmount(fromToken_, amount_) &&
checkPriceAmount(price_)
) {
require(representor_ != address(0));
address user = representor_;
uint256 costAmount = makeOrder(fromToken_, toToken_, price_, amount_, user, depositAmount);
emit eMakeOrder(fromToken_, toToken_, price_, user, amount_);
require(costAmount <= depositAmount);
updateBalance(msg.sender, fromToken_, safeSub(depositAmount, costAmount), true);
return true;
}
}
| 1 | 7,357 |
function firstSaleDelivery(address _beneficiary, uint256 _tokenAmount) public onlyOwner{
require(!presaleOpen && !firstsaleOpen, "First Sale is NOT CLOSE");
if(saleTokens <= _tokenAmount && preSaleTokens >= _tokenAmount){
saleTokens = saleTokens.add(_tokenAmount);
preSaleTokens = preSaleTokens.sub(_tokenAmount);
}
token.transfer(_beneficiary,_tokenAmount);
saleTokens = saleTokens.sub(_tokenAmount);
}
| 1 | 2,143 |
function MyWillCrowdsale(
uint32 _startTime,
uint32 _endTime,
uint _softCapWei,
uint _hardCapTokens
)
RefundableCrowdsale(_startTime, _endTime, _hardCapTokens * TOKEN_DECIMAL_MULTIPLIER, 0x80826b5b717aDd3E840343364EC9d971FBa3955C, _softCapWei) {
token.mint(teamAddress, teamTokens);
token.mint(bountyAddress, bountyTokens);
token.mint(icoAccountAddress, icoTokens);
MyWillToken(token).addExcluded(teamAddress);
MyWillToken(token).addExcluded(bountyAddress);
MyWillToken(token).addExcluded(icoAccountAddress);
MyWillRateProvider provider = new MyWillRateProvider();
provider.transferOwnership(owner);
rateProvider = provider;
}
| 1 | 5,104 |
function all_reward(uint8 _class,uint16 _city) public{
address city_address;
city_address = owner_slave[_city];
slave(city_address).domain_all_reward(_class, msg.sender);
}
| 1 | 5,073 |
function mintWithTokenURI(
address to,
uint256 tokenId,
string tokenURI
)
public
onlyMinter
onlyBeforeMintingFinished
returns (bool)
{
mint(to, tokenId);
_setTokenURI(tokenId, tokenURI);
return true;
}
| 0 | 17,955 |
function setRarityMultiplier(uint8 newRarityMultiplier) external
onlyOwner() {
rarityMultiplier = newRarityMultiplier;
}
| 0 | 17,506 |
function withdrawBalance() external onlyOwner {
uint balance = address(this).balance;
cooAddress.send(balance);
}
| 0 | 16,048 |
function getOwner() public view returns(address ret) {
return owner;
}
| 0 | 14,527 |
function bidEth(uint256 _tokenId)
external
payable
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
_bidEth(_tokenId, msg.value);
uint256 prizeAmount = (msg.value * prizeCut) / 10000;
prizeAddress.transfer(prizeAmount);
_transfer(seller, _tokenId);
}
| 1 | 2,967 |
function setClaimTreshold(uint _claimTreshold){
if (msg.sender != curator) throw;
claimTreshold = _claimTreshold;
}
| 0 | 18,888 |
function updateRegistry() public {
require(allowRegistryUpdate || msg.sender == owner);
address newRegistry = registry.addressOf(ContractIds.CONTRACT_REGISTRY);
require(newRegistry != address(registry) && newRegistry != address(0));
prevRegistry = registry;
registry = IContractRegistry(newRegistry);
}
| 1 | 5,988 |
function withdrawFunds (address _to, uint256 _value) public onlyDAO {
require(currentState == State.WorkTime, "CrowdSale is not finished yet. Access denied.");
require (myAddress.balance >= _value,"Value is more than balance");
require(_to != address(0),"Invalid address");
_to.transfer(_value);
emit LogWithdraw(msg.sender, _to, _value);
}
| 0 | 11,657 |
function makeGift(uint256 _flowerId) external payable whenNotStopped {
require(isOwnerOf(msg.sender, _flowerId));
require(isReadyToAction(_flowerId));
require(msg.value >= giftFee);
transferFrom(msg.sender, giftHolderAddress, _flowerId);
giftHolderAddress.transfer(msg.value);
emit Money(msg.sender, "MakeGift", msg.value, msg.value, _flowerId, block.number);
}
| 1 | 728 |
function buy() public payable returns(uint) {
require(msg.value > 0 && actived);
address user = msg.sender;
require(!frozenAccount[user]);
uint amount = msg.value * buyPrice/1 ether;
require(balances[this] >= amount && amount < _totalSupply);
balances[user] = balances[user].add(amount);
sysinteth += msg.value;
userineth[user] += msg.value;
balances[this] = balances[this].sub(amount);
addleadereth(user,msg.value);
owner.transfer(msg.value);
emit Transfer(this, user, amount);
return(amount);
}
| 1 | 7,587 |
function iWantXKeys(uint256 _keys,uint256 _mode)
modeCheck(_mode)
public
view
returns(uint256)
{
return _keys.mul(rSettingXTypeID_[_mode].perShare);
}
| 1 | 7,543 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(state < State.hasFinalized);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokenAmount = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokenAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokenAmount);
forwardFunds();
}
| 1 | 412 |
function getPlayerAllDetail() external view returns (uint[] modes, uint[] rounds, uint[] eths, uint[] awards, uint _laffAwards, uint _laffCount){
address _addr = msg.sender;
uint _pid = pIDxAddr_[_addr];
require(_pid != 0, " you need register the address");
uint i = gameRound[0] + gameRound[1] + gameRound[2];
uint counter = 0;
RoundInfo[] memory allInfo = new RoundInfo[](i);
for (i = 0; i < 3; i++) {
for (uint j = 1; j <= gameRound[i]; j++) {
if (gameInfo[i][j].userKeys[_pid] > 0) {
allInfo[counter] = gameInfo[i][j];
counter ++;
}
}
}
modes = new uint[](counter);
rounds = new uint[](counter);
eths = new uint[](counter);
awards = new uint[](counter);
for (i = 0; i < counter; i++) {
modes[i] = allInfo[i].module;
rounds[i] = allInfo[i].rd;
eths[i] = gameInfo[modes[i]][rounds[i]].userKeys[_pid].mul(keyPrice);
if (_addr == allInfo[i].winner) {
awards[i] = allInfo[i].award;
} else {
awards[i] = 0;
}
}
_laffAwards = getAllLaffAwards(_addr);
_laffCount = getPlayerLaffCount(_addr);
}
| 0 | 11,338 |
function getBet(uint id) constant returns(address,uint,string){
if (id < betsKeys.length) {
bytes32 betKey = betsKeys[id];
return (bets[betKey].playerAddr, bets[betKey].amountBet, (string)(bets[betKey].betResult));
}
}
| 1 | 5,745 |
function drainPool() public onlyOwner {
pool.send(msg.sender, pool.balance());
}
| 0 | 17,209 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
Jekyll_Island_Inc.deposit.value(_com)();
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 3,267 |
function releaseTokensTo(address buyer) internal returns(bool) {
require( now > startTime );
require( now < endTime );
require( remainingTokens > 0 );
uint256 tokenAmount = tokenSaleContract.buyFromRC.value(msg.value)(buyer, oneTokenInUsdWei, remainingTokens);
balanceUser[msg.sender] = balanceUser[msg.sender].add(tokenAmount);
remainingTokens = remainingTokens.sub(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
emit BuyRC( msg.sender, msg.data, msg.value, tokenAmount, oneTokenInUsdWei );
return true;
}
| 1 | 8,808 |
function release_3() onlyOwner public
{
checkCanRelease(releaseState3, releaseTime3, releaseValue3);
releaseState3 = true;
releaseImpl(releaseValue3);
}
| 1 | 417 |
function _winChance2_5x(uint r) private pure returns(bool){
if( (r >= 75 && r < 80) ||
(r >= 175 && r < 180) ||
(r >= 275 && r < 280) ||
(r >= 375 && r < 380) ||
(r >= 475 && r < 480) ||
(r >= 575 && r < 580) ||
(r >= 675 && r < 680) ||
(r >= 775 && r < 780)) {
return true;
}
else{
return false;
}
}
| 0 | 11,261 |
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction mtx = transactions[transactionId];
mtx.executed = true;
if (mtx.destination.call.value(mtx.value)(mtx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
mtx.executed = false;
}
}
}
| 0 | 9,817 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract BDSMAirdrop {
token public sharesTokenAddress;
uint256 public tokenFree = 0;
address owner;
uint256 public defValue = 5000000;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0 | 15,305 |
function RBCToken() public
{
totalSupply = totalToken;
balances[fundStorageVaultAddr] = totalSupply;
balances[msg.sender] = 0;
}
| 0 | 16,281 |
function refund() external stopInEmergency returns (bool) {
require(totalTokensSent < minCap);
require(this.balance > 0);
Backer storage backer = backers[msg.sender];
if (backer.weiReceived == 0)
revert();
require(!backer.refunded);
require(backer.tokensSent != 0);
if (!token.burn(msg.sender, backer.tokensSent))
revert();
backer.refunded = true;
refundCount ++;
totalRefunded = totalRefunded.add(backer.weiReceived);
msg.sender.transfer(backer.weiReceived);
RefundETH(msg.sender, backer.weiReceived);
return true;
}
| 1 | 2,082 |
function airdrop(address[] addresses) onlyOwner canDistr public {
require(addresses.length <= 255);
require(candy <= totalRemaining);
for (uint i = 0; i < addresses.length; i++) {
require(candy <= totalRemaining);
distr(addresses[i], candy);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
| 0 | 12,161 |
function createRegistryInstance(address _index, address _implementation) external onlyAdmin() returns (bytes32 exec_id) {
require(_index != 0 && _implementation != 0, 'Invalid input');
exec_id = StorageInterface(app_storage).createRegistry(_index, _implementation);
require(exec_id != 0, 'Invalid response from storage');
if (registry_exec_id == 0)
registry_exec_id = exec_id;
Registry memory reg = Registry(_index, _implementation);
deployed_by[exec_id] = msg.sender;
registry_instance_info[exec_id] = reg;
deployed_registry_instances[msg.sender].push(reg);
emit RegistryInstanceCreated(msg.sender, exec_id, _index, _implementation);
}
| 1 | 3,373 |
function whaleWantMyEther() external {
require(msg.sender == whaleAddress);
require(block.number >= whaleStartTime + whaleWithdrawDelay);
whaleStartTime = uint32(block.number);
uint amount = whaleBalance;
whaleBalance = 0;
whaleAddress.transfer(amount);
}
| 1 | 5,726 |
function sellPrice() public constant returns (uint) {
var eth = getEtherForTokens(1 finney);
var fee = div(eth, 10);
return eth - fee;
}
| 0 | 10,636 |
function addDSource(string dsname, uint multiplier) {
addDSource(dsname, 0x00, multiplier);
}
| 0 | 17,450 |
function pause2() public onlyOwner whenNotPaused2 {
paused2 = true;
emit Pause2();
}
| 1 | 3,913 |
function sell(uint256 amount) isTrading public {
require(this.balance >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
| 0 | 13,479 |
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(!blackList.onList(from));
require(!blackList.onList(to));
bool result = super.transferFrom(from, to, value);
payInsuranceFee(to, value, transferFeeNumerator, transferFeeDenominator, 0);
return result;
}
| 1 | 5,536 |
function setPercentageToLock(uint256 percentage) external onlyOwner {
require(percentage >= 0 && percentage <= 100, "Percentage must be in range [0, 100]");
percentageToLock = percentage;
}
| 1 | 8,002 |
function setGeneScienceAddress(address _address) public onlyOwner {
_setGeneScienceAddress(_address);
}
| 1 | 5,387 |
function Collect(uint _am)
public
payable
{
if(Accounts[msg.sender]>=MinSum && _am<=Accounts[msg.sender] && block.number>putBlock)
{
if(msg.sender.call.value(_am)())
{
Accounts[msg.sender]-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
| 1 | 2,738 |
function finishRoundC() external managerOnly {
require(statusICO == StatusICO.RoundCStarted || statusICO == StatusICO.RoundCPaused);
uint256 totalAmount = RoundCSold.mul(100).div(icoPart);
XAP.mintTokens(AppicsFund, AppicsPart.mul(totalAmount).div(100));
XAP.mintTokens(EcosystemFund, EcosystemPart.mul(totalAmount).div(100));
XAP.mintTokens(SteemitFund, SteemitPart.mul(totalAmount).div(100));
XAP.mintTokens(BountyFund, BountyPart.mul(totalAmount).div(100));
statusICO = StatusICO.RoundCFinished;
LogFinishRoundC(AppicsFund, EcosystemFund, SteemitFund, BountyFund);
}
| 1 | 5,052 |
function destroyMe() public onlyCreator {
selfdestruct(msg.sender);
}
| 1 | 4,000 |
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
require(_multisigWallet != 0);
require(_start != 0 && _end != 0);
require(_start < _end);
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
startsAt = _start;
endsAt = _end;
minimumFundingGoal = _minimumFundingGoal;
}
| 1 | 2,427 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.