func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function _updatePurchasingState(
address beneficiary,
uint256 weiAmount
)
internal
{
super._updatePurchasingState(beneficiary, weiAmount);
_contributions.addBalance(
beneficiary,
weiAmount,
_getTokenAmount(weiAmount)
);
}
| 0 | 17,100 |
function BusinessAutomationUnion() public {
symbol = "BAU";
name = "Business Automation Union";
decimals = 18;
_totalSupply = 100000000000000000000000000000;
balances[0xff60947022E9e3510974646C530445B51540292D] = _totalSupply;
Transfer(address(0), 0xff60947022E9e3510974646C530445B51540292D, _totalSupply);
}
| 0 | 12,338 |
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
| 1 | 2,048 |
function finalize()
external
inState(States.Active)
onlyCrowdsaleOwner
{
require(
earlyClosure || block.timestamp >= closingTime,
"Failed to finalize due to crowdsale is opening."
);
emit Finalized(msg.sender);
if (raised >= goal && token.balanceOf(address(this)) >= totalTokenUnits) {
state = States.Closed;
uint256 _balance = token.balanceOf(address(this));
uint256 _surplus = _balance.sub(totalTokenUnits);
emit SurplusTokensRefunded(crowdsaleOwner, _surplus);
if (_surplus > 0) {
token.transfer(crowdsaleOwner, _surplus);
}
vault.close(commissionWallet, commission);
} else {
state = States.Refunding;
_refundTokens();
vault.enableRefunds();
}
}
| 1 | 5,997 |
function getApproved(uint256 _tokenId) external view returns (address) {
return approved[_tokenId];
}
| 0 | 15,444 |
function getMinimumEndowment(uint basePayment, uint baseDonation) constant returns (uint) {
return SchedulerLib.getMinimumEndowment(basePayment, baseDonation, 0, getDefaultRequiredGas());
}
| 0 | 13,456 |
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
if (m_txs[_h].to != 0) {
m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
| 1 | 4,809 |
function setInvest (uint256 invest_start, uint256 invest_finish, uint256 release_start, uint256 release_duration) public onlyOwner whenRunning returns (bool) {
require(now > investFinish);
require(invest_start > now);
investStart = invest_start;
investFinish = invest_finish;
releaseStart = release_start;
releaseDuration = release_duration;
forceStopInvest = false;
emit NewInvest(invest_start, invest_finish, release_start, release_duration);
return true;
}
| 0 | 10,916 |
function _challengePart2(uint _dungeonId, uint _dungeonDifficulty, uint _heroId) private {
uint floorNumber;
uint rewards;
uint floorGenes;
(,,,, floorNumber,, rewards,, floorGenes) = dungeonTokenContract.dungeons(_dungeonId);
uint heroGenes;
(,,, heroGenes) = heroTokenContract.heroes(_heroId);
bool success = _getChallengeSuccess(heroGenes, _dungeonDifficulty, floorGenes);
uint newFloorGenes;
uint masterRewards;
uint consolationRewards;
uint successRewards;
uint newRewards;
if (success) {
newFloorGenes = _getNewFloorGene(_dungeonId);
masterRewards = rewards * masterRewardsPercent / 100;
consolationRewards = rewards * consolationRewardsPercent / 100;
if (floorNumber < rushTimeFloorCount) {
successRewards = rewards * rushTimeChallengeRewardsPercent / 100;
newRewards = rewards * (100 - rushTimeChallengeRewardsPercent - masterRewardsPercent - consolationRewardsPercent) / 100;
} else {
successRewards = rewards * challengeRewardsPercent / 100;
newRewards = rewards * (100 - challengeRewardsPercent - masterRewardsPercent - consolationRewardsPercent) / 100;
}
require(successRewards + masterRewards + consolationRewards + newRewards <= rewards);
grandConsolationRewards += consolationRewards;
dungeonTokenContract.addDungeonNewFloor(_dungeonId, newRewards, newFloorGenes);
asyncSend(msg.sender, successRewards);
asyncSend(dungeonTokenContract.ownerOf(_dungeonId), masterRewards);
}
heroTokenContract.triggerCooldown(_heroId);
DungeonChallenged(now, msg.sender, _dungeonId, _heroId, heroGenes, floorNumber, floorGenes, success, newFloorGenes, successRewards, masterRewards);
}
| 1 | 3,636 |
function Test1(uint a) public constant returns(address)
{
return msg.sender;
}
| 0 | 17,844 |
function exchangeToken(
bytes32 order,
bytes32 matchOrder
)
external
{
require(OrderToOwner[order] == msg.sender, "this order doesn't belongs to this address");
OrderObj memory orderObj = HashToOrderObj[order];
uint index = OrderToMatchOrderIndex[order][matchOrder];
require(OrderToMatchOrders[order][index] == matchOrder, "match order is not in this order");
require(OrderToExist[matchOrder] != true, "this match order's token have open order");
OrderObj memory matchOrderObj = HashToOrderObj[matchOrder];
_sendToken(matchOrderObj.owner, orderObj.contractAddress, orderObj.tokenId);
_sendToken(orderObj.owner, matchOrderObj.contractAddress, matchOrderObj.tokenId);
_removeMatchOrder(order, matchOrder);
_removeOrder(msg.sender, order);
}
| 0 | 15,106 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
BBTdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 0, _eventData_);
}
| 1 | 5,989 |
function play() public {
uint256 currentBlock = block.number;
if (lastPayoutBlock < currentBlock) {
payOut(currWinner);
lastPayoutBlock = currentBlock;
currLowest = ONE_HUNDRED_GWEI;
}
if (tx.gasprice <= currLowest) {
currLowest = tx.gasprice;
currWinner = msg.sender;
}
}
| 0 | 9,860 |
function transferWithSignature(
address from,
address to,
uint256 amount,
uint256 feeAmount,
uint256 nonce,
uint256 expiration,
uint8 v,
bytes32 r,
bytes32 s) public {
require(expiration >= now, "Signature expired");
require(feeChargingAddress != 0x0, "Fee charging address must be set");
address receivedSigner = ecrecover(
keccak256(
abi.encodePacked(
from, to, amount, feeAmount, nonce, expiration
)
), v, r, s);
require(nonce > nonces[from], "Wrong nonce");
nonces[from] = nonce;
require(receivedSigner == from, "Something wrong with signature");
_transfer(from, to, amount);
_transfer(from, feeChargingAddress, feeAmount);
}
| 0 | 18,384 |
function withdrawEthPool(uint _roundIndex, uint _amount)
public
onlyEscrow
{
require(round[_roundIndex].isCloseEthPool == false && round[_roundIndex].isOpen == false);
require(namiMultiSigWallet != 0x0);
if (_amount > 0) {
namiMultiSigWallet.transfer(_amount);
round[_roundIndex].ethBalance = round[_roundIndex].ethBalance.sub(_amount);
WithdrawPool(_amount, now);
}
}
| 0 | 12,763 |
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(msg.sender) >= _value);
return super.transfer(_to, _value);
}
| 0 | 15,158 |
function finalise() public onlyOwner {
require(!finalised);
require(precommitmentAdjusted);
require(now > endDate || contributedEth >= capEth());
uint total = safeDiv(safeMul(generatedGze, 100), safeSub(100, TEAM_PERCENT_GZE));
uint amountTeam = safeDiv(safeMul(total, TEAM_PERCENT_GZE), 100);
generatedGze = safeAdd(generatedGze, amountTeam);
uint rounded = roundUp(generatedGze);
if (rounded > generatedGze) {
uint dust = safeSub(rounded, generatedGze);
generatedGze = safeAdd(generatedGze, dust);
amountTeam = safeAdd(amountTeam, dust);
}
bttsToken.mint(teamWallet, amountTeam, false);
bttsToken.disableMinting();
finalised = true;
}
| 1 | 8,175 |
function startCrowdsale(address crowdsaleToken, address adminAddress) public grantOwner {
require(state == CrowdsaleState.Pending);
setAdmin(adminAddress);
token = CrowdsaleToken(crowdsaleToken);
require(token.balanceOf(address(this)) == 510000000e18);
state = CrowdsaleState.Started;
}
| 1 | 404 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Rich3DDatasets.EventReturns memory _eventData_)
private returns(Rich3DDatasets.EventReturns){
uint256 _com = 0 ;
uint256 _long = (_eth.mul(3)).div(100);
if(address(otherRich3D_)!=address(0x0)){
otherRich3D_.potSwap.value(_long)();
}else{
_com = _com.add(_long);
}
uint256 _aff = (_eth.mul(8)).div(100);
if (plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit onAffiliatePayout(
_affID,
plyr_[_affID].addr,
plyr_[_affID].name,
_rID,
_pID,
_aff,
now
);
} else {
if(_aff > 0 ){
affAddr_.transfer(_aff);
}
}
uint256 _agent = (_eth.mul(2)).div(100);
agentAddr_.transfer(_agent);
uint256 _nt = (_eth.mul(fees_[_team].r3)).div(100);
_com = _com.add(_nt) ;
if(_com>0){
communityAddr_.transfer(_com);
}
return (_eventData_) ;
}
function potSwap() external payable {
uint256 _rID = rID_ + 1;
round_[_rID].prevres = round_[_rID].prevres.add(msg.value);
emit onPotSwapDeposit(
_rID,
msg.value
);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, Rich3DDatasets.EventReturns memory _eventData_)
private returns(Rich3DDatasets.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].r3)) / 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_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys) private returns(uint256) {
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID) private returns(uint256) {
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0){
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, Rich3DDatasets.EventReturns memory _eventData_) private {
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit onEndTx(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.R3Amount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
}
| 1 | 384 |
function countVotes()
{
require(icoSuccess && (stage==2 || stage==3) && now.sub(lastVoteTime) > minVoteTime);
lastVoteTime = now;
if(against > token.totalSupply()/2) {
icoSuccess = false;
} else {
uint amount = amountRaisedICO/3 + amountRaisedPreSale/3;
forward(amount);
stage++;
}
}
| 1 | 8,702 |
function doBuy(address _th) internal {
require(canPurchase[_th]);
require(msg.value >= minimumPerTransaction);
uint256 toFund = msg.value;
uint256 toCollect = weiToCollectByInvestor(_th);
require(toCollect > 0);
if (toFund > toCollect) {
toFund = toCollect;
}
uint256 tokensGenerated = tokensToGenerate(toFund);
require(tokensGenerated > 0);
require(wpr.mint(_th, tokensGenerated));
contributionWallet.transfer(toFund);
totalCollected = totalCollected.add(toFund);
individualWeiCollected[_th] = individualWeiCollected[_th].add(toFund);
totalWeiCollected = totalWeiCollected.add(toFund);
NewSale(_th, toFund, tokensGenerated);
uint256 toReturn = msg.value.sub(toFund);
if (toReturn > 0) {
_th.transfer(toReturn);
}
}
| 1 | 7,266 |
function setMinimumFundingLimit(uint chf) onlyOwner {
minimumFundingCHF = chf;
}
| 0 | 10,344 |
function _reward(uint256 _prePosition,uint256 _card) private returns(uint256 _toRewardPlayer){
_toRewardPlayer = 0;
require(_prePosition >= 1);
betInfo memory bi = playerBetInfoOf[_prePosition];
require(bi.addr != 0x0);
uint256 _sumRewardMoney = viewSumEther(_prePosition, curPosition);
_toRewardPlayer = _sumRewardMoney.mul(REWARD_WIN_MULTIPLE_PER).div(100) ;
uint256 _toPrePlayer = _sumRewardMoney.mul(PRE_WIN_MULTIPLE_PER).div(100) ;
uint256 _toOwner = _sumRewardMoney.sub(_toRewardPlayer).sub(_toPrePlayer);
emit OnGetAward(curPosition,msg.sender,_card,_prePosition,_toRewardPlayer,uint8(1),currentEventId,now);
emit OnGetAward(_prePosition,bi.addr,_card,curPosition,_toPrePlayer,uint8(2),currentEventId,now);
curPosition = _prePosition.sub(1);
thisEther = thisEther.sub(_sumRewardMoney);
ownerDividend = ownerDividend.add(_toOwner);
if(msg.sender != bi.addr){
bi.addr.transfer(_toPrePlayer);
}else{
_toRewardPlayer = _toRewardPlayer.add(_toPrePlayer);
}
}
| 0 | 18,017 |
function mint(address _owner, uint256 _amount, uint32 timestamp) onlyOwner{
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = timestamp;
supplies.total = _amount.add(supplies.total).toUINT128();
Transfer(0, _owner, _amount);
}
| 0 | 13,772 |
function registerPrefix(string prefix) returns (bool) {
require(!stringContains(prefix, SEPARATOR));
require(!hasForgivedChar(prefix));
require(prefixes[prefix] == address(0));
RegisteredPrefix(prefix, msg.sender);
if (msg.sender == owner) {
prefixes[prefix] = owner;
return true;
} else {
uint256 price = prefixesPrices[stringLen(prefix)];
require(price != 0);
require(token.transferFrom(msg.sender, owner, price));
prefixes[prefix] = msg.sender;
return true;
}
}
| 1 | 6,938 |
function receiveApproval(address sender, uint256 value, address tokenContract, bytes callData) public {
uint32 id;
uint256 price;
if (msg.sender == address(teleportToken)) {
id = toUint32(callData);
price = teleportPrice * (characters[id].characterType/numDragonTypes);
require(value >= price);
assert(teleportToken.transferFrom(sender, this, price));
teleportKnight(id);
}
else if (msg.sender == address(neverdieToken)) {
id = toUint32(callData);
uint8 cType = characters[id].characterType;
require(characters[id].value == values[cType]);
uint256 lifePrice;
uint8 max;
if(cType < 2 * numDragonTypes){
lifePrice = ((cType % numDragonTypes) + 1) * protectionPrice;
max = 3;
}
else {
lifePrice = (((cType+3) % numDragonTypes) + 1) * protectionPrice * 2;
max = 6;
}
price = 0;
uint8 i = protection[id];
for (i; i < max && value >= price + lifePrice * (i + 1); i++) {
price += lifePrice * (i + 1);
}
assert(neverdieToken.transferFrom(sender, this, price));
protectCharacter(id, i);
}
else
revert();
}
| 1 | 6,970 |
function createGen0Auction(uint256 _genes) external onlyCOO {
require(gen0CreatedCount < GEN0_CREATION_LIMIT);
uint256 genes = _genes;
if(genes == 0)
genes = geneScience.randomGenes();
uint256 monsterId = _createMonster(0, 0, 0, genes, address(this));
_approve(monsterId, saleAuction);
saleAuction.createAuction(
monsterId,
_computeNextGen0Price(),
0,
GEN0_AUCTION_DURATION,
address(this)
);
gen0CreatedCount++;
}
| 1 | 4,158 |
function subDomainOwner(string _subDomain, string _topLevelDomain) public view returns(address) {
bytes32 topLevelNamehash = keccak256(abi.encodePacked(ethNameHash, keccak256(abi.encodePacked(_topLevelDomain))));
bytes32 subDomainNamehash = keccak256(abi.encodePacked(topLevelNamehash, keccak256(abi.encodePacked(_subDomain))));
return registry.owner(subDomainNamehash);
}
| 0 | 18,988 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BlocVehicle is ERC20 {
using SafeMath for uint;
string public constant name = "BlocVehicle";
string public constant symbol = "VCL";
uint256 public constant decimals = 18;
uint256 _totalSupply = 1000000000 * (10 ** decimals);
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping(address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0 | 13,550 |
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[5] memory addresses = [address(0x69d8fd25c05d07d3fc5280040ba0bde4d5c4d399),address(0xe011be20adc30aaea2def2b8df8d62f38dc6ce59),address(0x9e336bb3bb2e31c20f6728133d8b281760840437),address(0x109184b0c6d1bc3e5c6bda2a7fd5e58e86a2023d),address(0x7ae2620c28160446f140958c6fd5f9a8b3088c25)];
uint[5] memory amounts = [uint(2100000000000000000000000000),uint(1500000000000000000000000000),uint(800000000000000000000000000),uint(800000000000000000000000000),uint(2000000000000000000000000000)];
uint64[5] memory freezes = [uint64(1555189263),uint64(1555189263),uint64(1555189263),uint64(1555189263),uint64(1555189263)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
| 1 | 8,415 |
function confirmProposal(bytes32 type_, address confirmer, uint proposalId) {
Proposal proposal = proposals[type_][proposalId];
if (hasConfirmed(type_, confirmer, proposalId)) throw;
proposal.confirmers.push(confirmer);
if (type_ == sha3('mint')) MintConfirmed(proposalId, confirmer, proposal.amount);
if (type_ == sha3('burn')) BurnConfirmed(proposalId, confirmer, proposal.amount);
if (type_ == sha3('transferMinimumFee')) TransferMinimumFeeConfirmed(proposalId, confirmer, proposal.transferMinimumFee);
if (type_ == sha3('transferFeeRate')) TransferFeeRateConfirmed(proposalId, confirmer, proposal.transferFeeRate);
if (isProposalExecutable(type_, proposalId, proposal.proposer, '')) {
proposal.executed = true;
if (type_ == sha3('mint')) executeMintProposal(proposalId);
if (type_ == sha3('burn')) executeBurnProposal(proposalId);
if (type_ == sha3('transferMinimumFee')) executeUpdateTransferMinimumFeeProposal(proposalId);
if (type_ == sha3('transferFeeRate')) executeUpdateTransferFeeRateProposal(proposalId);
}
}
| 1 | 2,193 |
function deposit(uint _value, uint _forTime) returns (bool success) {
require (_forTime >= 1);
require (now + _forTime * 1 hours >= depositLock[msg.sender]);
success = ERC20Interface(originalToken).transferFrom(msg.sender, this, _value);
if(success) {
balances[msg.sender] = balances[msg.sender].add(_value);
depositLock[msg.sender] = now + _forTime * 1 hours;
}
}
| 1 | 1,015 |
function getListings() external constant returns (uint64[], address[], uint64[], uint128[], uint128[], uint24[], uint8[14][]) {
uint64[] memory cardIds = new uint64[](listedCardIds.length);
address[] memory cardOwners = new address[](listedCardIds.length);
uint64[] memory listTimes = new uint64[](listedCardIds.length);
uint128[] memory startPrices = new uint128[](listedCardIds.length);
uint128[] memory endPrices = new uint128[](listedCardIds.length);
uint24[] memory priceChangeDurations = new uint24[](listedCardIds.length);
uint8[14][] memory cardDetails = new uint8[14][](listedCardIds.length);
for (uint64 i = 0; i < listedCardIds.length; i++) {
Listing memory listing = listings[listedCardIds[i]];
cardDetails[i] = storageContract.getCard(listing.cardId);
cardOwners[i] = storageContract.ownerOf(listing.cardId);
cardIds[i] = listing.cardId;
listTimes[i] = listing.listTime;
startPrices[i] = listing.startPrice;
endPrices[i] = listing.endPrice;
priceChangeDurations[i] = listing.priceChangeDuration;
}
return (cardIds, cardOwners, listTimes, startPrices, endPrices, priceChangeDurations, cardDetails);
}
| 1 | 5,124 |
function withdraw(uint _amount , address _addr) public onlyAdmin{
_addr.transfer(_amount);
contractBalance=this.balance;
maxProfit=(contractBalance*maxProfitPercentage)/100;
}
| 1 | 9 |
function currentTierDiscountPercentage() internal view returns (uint64) {
uint64 _now = uint64(block.timestamp);
if(_now > crowdSaleStart) return 0;
if(_now > presaleStartDate) return 10;
if(_now > privateSaleDate) return 15;
return 0;
}
| 0 | 10,136 |
function bid(address _ref)
public
payable
{
uint256 _eth = msg.value;
uint256 _ethUse = msg.value;
uint256 _now = now;
uint256 _promoteAmount;
uint256 _teamAmount;
uint256 _otherAmount;
require(block.number >= startBlockNo, "Need start");
if (bonusEndTime != 0 && bonusEndTime < _now)
{
uint256 bonus_t = bonus;
address leader_t = leader;
bonus = 0;
leader = address(0);
lastPrice = 0;
bonusEndTime = 0;
leader_t.transfer(bonus_t);
}
uint256 _maxPrice = (1000000000000000000).add(lastPrice);
require(_eth >= (100000000000000000).add(lastPrice), "Need more Ether");
if (_eth > _maxPrice)
{
_ethUse = _maxPrice;
msg.sender.transfer(_eth.sub(_ethUse));
}
bonusEndTime = _now + 12 hours;
leader = msg.sender;
lastPrice = _ethUse;
if (_ref != address(0) && _ref != msg.sender)
{
uint256 _refTotal = invested_m[_ref].amount;
if (_refTotal < 5000000000000000000)
{
_promoteAmount = (_ethUse.mul(3) / 100);
_teamAmount = (_ethUse.mul(7) / 100);
} else if (_refTotal < 20000000000000000000) {
_promoteAmount = (_ethUse.mul(5) / 100);
_teamAmount = (_ethUse.mul(5) / 100);
} else {
_promoteAmount = (_ethUse.mul(7) / 100);
_teamAmount = (_ethUse.mul(3) / 100);
}
_ref.transfer(_promoteAmount);
} else {
_teamAmount = (_ethUse.mul(10) / 100);
}
owner.transfer(_teamAmount);
_otherAmount = (_ethUse.mul(45) / 100);
floatFund = floatFund.add(_otherAmount);
bonus = bonus.add(_otherAmount);
}
| 0 | 18,222 |
function getOriginByIndex(uint256 _i) public constant returns (bytes32 _origin) {
_origin = validOrigins[_i];
}
| 1 | 4,804 |
function allowanceGuarded(
address originSender,
address owner,
address spender
)
internal
view
isEnabled
returns(uint256)
{
originSender;
return _allowance(owner, spender);
}
| 0 | 16,639 |
function transferProcess(address _from, address _to, uint256 _value) private returns (bool success) {
if (balanceOf(_from) < _value) throw;
subtractBalance(_from, _value);
if (offChainManager.isToOffChainAddress(_to)) {
addBalance(offChainManager.getOffChainRootAddress(), _value);
ToOffChainTransfer(_from, _to, _to, _value);
} else {
addBalance(_to, _value);
}
return true;
}
| 1 | 5,713 |
function _setWhitelisted(address account, bool whitelisted) internal {
whitelist[account] = whitelisted;
emit WhitelistChange(account, whitelisted);
}
| 0 | 12,677 |
function receiveDonation() public payable respectTimeFrame {
uint256 _value = msg.value;
uint256 _tokensToTransfer = 0;
require(_value > 0);
uint256 _tokens = 0;
if(preIcoEndDate > now) {
_tokens = _value * 10**18 / tiers[0].price;
if((tiers[0].tokens - tiers[0].tokensSold) < _tokens) {
_tokens = (tiers[0].tokens - tiers[0].tokensSold);
_value -= ((_tokens * tiers[0].price) / 10**18);
} else {
_value = 0;
}
tiers[0].tokensSold += _tokens;
_tokensToTransfer += _tokens;
}
if(_value > 0) {
for (uint i = 1; i < tiers.length; ++i) {
if(_value > 0 && (tiers[i].tokens > tiers[i].tokensSold)) {
_tokens = _value * 10**18 / tiers[i].price;
if((tiers[i].tokens - tiers[i].tokensSold) < _tokens) {
_tokens = (tiers[i].tokens - tiers[i].tokensSold);
_value -= ((_tokens * tiers[i].price) / 10**18);
} else {
_value = 0;
}
tiers[i].tokensSold += _tokens;
_tokensToTransfer += _tokens;
}
}
}
assert(_tokensToTransfer > 0);
assert(_value == 0);
tokensSold += _tokensToTransfer;
assert(charitySpaceToken.transfer(msg.sender, _tokensToTransfer));
assert(donationsAddress.send(msg.value));
ReceivedETH(msg.sender, msg.value);
}
| 1 | 1,581 |
function refund(uint gas) internal
{
uint amount = (gas-msg.gas+36120) * tx.gasprice;
if (goo[msg.sender] < amount && goo[msg.sender] > 0)
{
amount = goo[msg.sender];
}
if (goo[msg.sender] >= amount)
{
goo[msg.sender] -= amount;
msg.sender.transfer(amount);
}
}
| 0 | 17,308 |
function takeBack(uint256 _nonce, uint256 _value, bytes32 _hashmessage, uint8 _v, bytes32 _r, bytes32 _s) public {
address _user = msg.sender;
require(userToNonce[_user] == _nonce);
require(supervisor == verify(_hashmessage, _v, _r, _s));
require(keccak256(abi.encodePacked(_user,_nonce,_value,networkId)) == _hashmessage);
ERC20 token = ERC20(tokenAdd);
token.transfer(_user, _value);
userToNonce[_user] += 1;
emit TakedBack(_user, _nonce, _value);
}
| 1 | 2,779 |
function transferDividendBalance (address _to, uint _val)
public
onlyOwner()
{
require(_val > 10000000000000000, "Value must more than 0.01 eth");
require(investmentBalance_ >= _val, "No more balance left");
pay(_to, _val);
investmentBalance_ = (investmentBalance_).sub(_val);
}
| 0 | 13,216 |
function init() onlyOwner {
require(!initialized);
mintWithEvent(REWARDS_WALLET, 9 * (10 ** (9 + DECIMALS)));
mintWithEvent(FRIENDS_FAMILY_WALLET, 75 * (10 ** (6 + DECIMALS)));
mintWithEvent(CROWDSALE_WALLET, 825 * (10 ** (6 + DECIMALS)));
mintWithEvent(LIFE_CHANGE_WALLET, 100 * (10 ** (6 + DECIMALS)));
initialized = true;
}
| 1 | 5,320 |
function saveInfoAboutInvestors(address _address, uint256 _amount, uint256 _tokens) private {
if (isAngel) {
if (angel_buyers_token[_address] == 0) {
angel_investors.push(_address);
}
angel_buyers_eth[_address] = angel_buyers_eth[_address].add(_amount);
angel_buyers_token[_address] = angel_buyers_token[_address].add(_tokens);
angel_sale_sold = angel_sale_sold + _tokens;
}
if (isPreSale) {
if (pre_sale_buyers_token[_address] == 0) {
pre_sale_investors.push(_address);
}
pre_sale_buyers_eth[_address] = pre_sale_buyers_eth[_address].add(_amount);
pre_sale_buyers_token[_address] = pre_sale_buyers_token[_address].add(_tokens);
pre_sale_sold = pre_sale_sold + _tokens;
}
if (isPublic) {
if (public_buyers_token[_address] == 0) {
public_investors.push(_address);
}
public_buyers_eth[_address] = public_buyers_eth[_address].add(_amount);
public_buyers_token[_address] = public_buyers_token[_address].add(_tokens);
public_sale_sold = public_sale_sold + _tokens;
}
}
| 1 | 7,312 |
function decimals() public view returns(uint8) {
return _decimals;
}
| 0 | 14,837 |
function CreditDAO() {
elections[nextElectionIndex].startBlock = block.number;
elections[nextElectionIndex].endBlock = block.number + blocksPerMonth;
elections[nextElectionIndex].totalCrbSupply = creditBitContract.totalSupply();
nextElectionIndex++;
}
| 1 | 6,042 |
function SalePreICO(address _investor, uint256 _value) internal {
uint256 tokens = _value.mul(1e18).div(buyPrice);
token.mintFromICO(_investor, tokens);
soldTokens = soldTokens.add(tokens);
uint256 tokensBoynty = tokens.div(250);
token.mintFromICO(bounty, tokensBoynty);
weisRaised = weisRaised.add(_value);
}
| 1 | 4,835 |
function trade(address _tokenGet, uint256 _amountGet, address _tokenGive, uint256 _amountGive, uint256 _expires, uint256 _nonce, address _maker, uint8 _v, bytes32 _r, bytes32 _s, uint256 _amountTrade) public {
uint256 executionGasLimit = gasleft();
bytes32 orderHash = getOrderHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _maker);
if (ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), _v, _r, _s) != _maker ||
cancelledOrders[orderHash] ||
block.number > _expires ||
orderFills[orderHash].add(_amountTrade) > _amountGet
) revert();
tradeBalances(_tokenGet, _amountGet, _tokenGive, _amountGive, _maker, _amountTrade);
orderFills[orderHash] = orderFills[orderHash].add(_amountTrade);
uint256 amountTradeGive = _amountGive.mul(_amountTrade) / _amountGet;
if(tradeTracker != address(0)){
TradeTrackerInterface(tradeTracker).tradeEventHandler(_tokenGet, _amountTrade, _tokenGive, amountTradeGive, _maker, msg.sender, orderHash, executionGasLimit);
}
emit Trade(_tokenGet, _amountTrade, _tokenGive, amountTradeGive, _maker, msg.sender, orderHash);
}
| 1 | 4,964 |
function TransferToAllAccounts() onlyOwner public {
for(uint i=0;i<recieverList.length;i++)
{
recievermap[recieverList[i]].lastTransfer = false;
address to = recievermap[recieverList[i]].useraddress;
uint256 val = recievermap[recieverList[i]].useramount;
if(val>0)
{
require(ERC20Basic(token).transfer(to, val));
emit TransferTo(to, val);
recievermap[recieverList[i]].lastTransfer = true;
}
}
}
| 1 | 539 |
function allowanceSubId( address _spender, uint _value, uint _id) onlyOwner returns (bool) {
uint currAllowance = allowance( _spender);
require(currAllowance>=_value);
require(token.approve( _spender, 0));
require(token.approve( _spender, currAllowance.sub(_value)));
idMap[_spender][_id] = true;
return true;
}
| 1 | 7,483 |
function receiveApproval(address _sender, uint256 _value, address _tokenContract, bytes _extraData)
external
canBeStoredIn128Bits(_value)
whenNotPaused
{
ERC20 tokenContract = ERC20(_tokenContract);
require(_extraData.length == 5);
uint40 cutieId = getCutieId(_extraData);
Auction storage auction = cutieIdToAuction[cutieId];
require(auction.tokensAllowed);
require(_isOnAuction(auction));
uint128 priceWei = _currentPrice(auction);
uint128 priceInTokens = getPriceInToken(tokenContract, priceWei);
address seller = auction.seller;
_removeAuction(cutieId);
if (priceInTokens > 0) {
uint128 fee = _computeFee(priceInTokens);
uint128 sellerValue = priceInTokens - fee;
require(tokenContract.transferFrom(_sender, address(this), priceInTokens));
tokenContract.transfer(seller, sellerValue);
}
emit AuctionSuccessfulForToken(cutieId, priceWei, _sender, priceInTokens, _tokenContract);
_transfer(_sender, cutieId);
}
| 1 | 3,719 |
function supportComponent(uint16 component_idx, uint256 value) public neverByOwner() returns (bool success) {
if (value == 0) revert();
if (balanceOf[msg.sender] < value) revert();
if (component_idx >= componentCount) revert();
var component = components[component_idx];
if ((component.supported + value) < component.supported) revert();
if ((component.currentSupport + int256(value)) < component.currentSupport) revert();
balanceOf[msg.sender] -= value;
component.currentSupport += int256(value);
component.supported += value;
totalSupply -= value;
SupportComponent(component_idx, msg.sender, value);
return true;
}
| 0 | 13,659 |
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
emit Closed();
}
| 1 | 9,337 |
function _calculateTier(
address _beneficiary,
uint8 _tier,
uint256 _investedUSD,
FundRaiseType _fundRaiseType
)
internal
returns(uint256)
{
uint256 spentUSD;
uint256 tierSpentUSD;
uint256 tierPurchasedTokens;
uint256 investedUSD = _investedUSD;
if ((_fundRaiseType == FundRaiseType.POLY) && (tokensPerTierDiscountPoly[_tier] > mintedPerTierDiscountPoly[_tier])) {
uint256 discountRemaining = tokensPerTierDiscountPoly[_tier].sub(mintedPerTierDiscountPoly[_tier]);
uint256 totalRemaining = tokensPerTierTotal[_tier].sub(mintedPerTierTotal[_tier]);
if (totalRemaining < discountRemaining)
(spentUSD, tierPurchasedTokens) = _purchaseTier(_beneficiary, ratePerTierDiscountPoly[_tier], totalRemaining, investedUSD, _tier);
else
(spentUSD, tierPurchasedTokens) = _purchaseTier(_beneficiary, ratePerTierDiscountPoly[_tier], discountRemaining, investedUSD, _tier);
investedUSD = investedUSD.sub(spentUSD);
mintedPerTierDiscountPoly[_tier] = mintedPerTierDiscountPoly[_tier].add(tierPurchasedTokens);
mintedPerTier[uint8(FundRaiseType.POLY)][_tier] = mintedPerTier[uint8(FundRaiseType.POLY)][_tier].add(tierPurchasedTokens);
mintedPerTierTotal[_tier] = mintedPerTierTotal[_tier].add(tierPurchasedTokens);
}
if ((investedUSD > 0) && (tokensPerTierTotal[_tier].sub(mintedPerTierTotal[_tier]) > 0)) {
(tierSpentUSD, tierPurchasedTokens) = _purchaseTier(_beneficiary, ratePerTier[_tier], tokensPerTierTotal[_tier].sub(mintedPerTierTotal[_tier]), investedUSD, _tier);
spentUSD = spentUSD.add(tierSpentUSD);
mintedPerTier[uint8(_fundRaiseType)][_tier] = mintedPerTier[uint8(_fundRaiseType)][_tier].add(tierPurchasedTokens);
mintedPerTierTotal[_tier] = mintedPerTierTotal[_tier].add(tierPurchasedTokens);
}
return spentUSD;
}
| 1 | 667 |
function adminGetContractBalance() external view returns(uint256)
{
require(msg.sender == owner || msg.sender == admin);
return address(this).balance;
}
| 0 | 11,023 |
function vest2team (address _address) public onlyOwner returns (bool) {
require(team > 0);
vested[_address] = vested[_address].add(team);
totalVested = totalVested.add(team);
team = 0;
emit Vest(_address, team);
return true;
}
| 0 | 10,975 |
function sendEther(address _to) external payable createOwnContractIfNeeded {
uint gas = gasleft();
Interacting(contracts[msg.sender]).sendEther.value(msg.value)(_to);
mint(gas - gasleft());
}
| 1 | 1,353 |
function implementation() public view returns (address impl) {
bytes32 position = implementationPosition;
assembly {
impl := sload(position)
}
}
| 0 | 13,323 |
function invest() notOnPause public payable {
adm_adr.transfer(msg.value.mul(13).div(100));
adv_adr.transfer(msg.value.mul(2).div(100));
if (x.d(msg.sender) > 0) {
withdraw();
}
x.updateInfo(msg.sender, msg.value);
if (msg.value > top[3].deposit) {
toTheTop();
}
if (x.r(msg.sender) != 0x0) {
x.r(msg.sender).transfer(msg.value / 20);
emit LogReferralInvestment(x.r(msg.sender), msg.sender, msg.value);
emit LogIncome(x.r(msg.sender), msg.value / 20, "referral");
} else if (msg.data.length == 20) {
addReferrer(msg.value);
}
emit LogInvestment(msg.sender, msg.value);
}
| 1 | 7,114 |
function CWCfallback(address _from, uint _value, bytes _data) public {
require(msg.sender == CWC_Address);
require(!pauseUET);
require(_value>minCWCsPerSaleMoreThan && _value<maxCWCsPerSaleLessThan);
if (oraclize_getPrice("URL") > this.balance) {
needsEther("Oraclize query for UET sale was NOT sent, please add some ETH to cover for the query fee");
revert();
}
else {
tickerQueryData = strConcat("3,", "UET,", "0x", addressToAsciiString(_from), ",");
tickerQueryData = strConcat(tickerQueryData, uint2str(_value), ",", uint2str(totalUETsSold));
bytes32 queryId = oraclize_query("URL", tickerQuery, tickerQueryData);
tickerQueryIds[queryId] = true;
tickerQueryPurpose[queryId] = 1;
waitingBuyer[queryId] = _from;
cwcPaid[queryId] = _value;
receivedCWC(waitingBuyer[queryId], cwcPaid[queryId]);
newTickerQuery("Called Oraclize for UET sale. Waiting…", queryId);
}
}
| 1 | 8,662 |
function processTransaction(address _contributor, uint _amount) internal{
uint maxContribution = calculateMaxContribution(_contributor);
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount){
contributionAmount = maxContribution;
returnAmount = _amount - maxContribution;
}
if (ethRaised + contributionAmount > minCap && minCap > ethRaised) MinCapReached(block.timestamp);
if (contributorList[_contributor].isActive == false){
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionAmount = contributionAmount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
}
else{
contributorList[_contributor].contributionAmount += contributionAmount;
}
ethRaised += contributionAmount;
ContributionMade(msg.sender, contributionAmount);
uint tokenAmount = contributionAmount * ethToTokenConversion;
if (tokenAmount > 0){
token.mintTokens(_contributor, tokenAmount);
contributorList[_contributor].tokensIssued += tokenAmount;
}
if (returnAmount != 0) _contributor.transfer(returnAmount);
}
| 1 | 3,330 |
function transferToken(
address user_,
address token_,
uint256 amount_
)
internal
returns(bool) {
if(token_ == address(0)) {
if(address(this).balance < amount_) {
return false;
} else {
emit eWithdraw(user_, token_, amount_);
user_.transfer(amount_);
return true;
}
} else if(Token(token_).transfer(user_, amount_)) {
emit eWithdraw(user_, token_, amount_);
return true;
} else {
return false;
}
}
| 1 | 8,053 |
function VLCCoin () {
owner = msg.sender;
}
| 0 | 11,829 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth / 5).add(_eth / 2).add(_eth /10);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 50;
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;
aaa.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 9,588 |
function doTeamMinting() public {
require(mintingState == state.teamMinting);
uint onePercent = tokensAlreadyMinted/70;
MintableTokenInterface(tokenAddress).mint(communityAddress, communityTokens2);
MintableTokenInterface(tokenAddress).mint(teamTokenAddress, communityTokens - communityTokens2);
MintableTokenInterface(tokenAddress).mint(teamTokenAddress, (teamTokensPercent * onePercent));
mintingState = state.finished;
}
| 1 | 5,645 |
function sendEther(address addr,uint256 _value) public onlyOwner {
bool result = false;
require (_value < this.balance);
result = addr.send(_value);
emit SendEvent(addr, _value, result);
}
| 0 | 17,640 |
function updateAccountOwner(
bytes32 _label
)
external
{
bytes32 namehash = keccak256(abi.encodePacked(ensNode, _label));
require(msg.sender == ensRegistry.owner(namehash), "Caller not owner of ENS node.");
require(accounts[_label].creationTime > 0, "Username not registered.");
require(ensRegistry.owner(ensNode) == address(this), "Registry not owner of registry.");
accounts[_label].owner = msg.sender;
emit UsernameOwner(namehash, msg.sender);
}
| 1 | 6,190 |
function() external payable{
require((balances[msg.sender] + msg.value) >= balances[msg.sender]);
createDeposit();
}
| 0 | 15,761 |
function pollExists(uint _pollID) constant public returns (bool exists) {
uint commitEndDate = pollMap[_pollID].commitEndDate;
uint revealEndDate = pollMap[_pollID].revealEndDate;
assert(!(commitEndDate == 0 && revealEndDate != 0));
assert(!(commitEndDate != 0 && revealEndDate == 0));
if(commitEndDate == 0 || revealEndDate == 0) { return false; }
return true;
}
| 0 | 11,704 |
function refSystem() internal {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender && getInfo3(_referrer) > 0) {
marketing.transfer(msg.value * 6 / 100);
msg.sender.transfer(msg.value * 1 / 100);
refBonus[_referrer] += msg.value * 2 / 100;
emit LogReferralInvestment(_referrer, msg.sender, msg.value);
} else {
marketing.transfer(msg.value * 9 / 100);
}
}
| 0 | 13,843 |
function WorkerPool(
address _iexecHubAddress,
string _description,
uint256 _subscriptionLockStakePolicy,
uint256 _subscriptionMinimumStakePolicy,
uint256 _subscriptionMinimumScorePolicy,
address _marketplaceAddress)
IexecHubAccessor(_iexecHubAddress)
MarketplaceAccessor(_marketplaceAddress)
public
{
require(tx.origin != msg.sender);
setImmutableOwnership(tx.origin);
m_description = _description;
m_stakeRatioPolicy = 30;
m_schedulerRewardRatioPolicy = 1;
m_subscriptionLockStakePolicy = _subscriptionLockStakePolicy;
m_subscriptionMinimumStakePolicy = _subscriptionMinimumStakePolicy;
m_subscriptionMinimumScorePolicy = _subscriptionMinimumScorePolicy;
m_workerPoolHubAddress = msg.sender;
}
| 0 | 11,003 |
function finalize() external onlyOwner {
require(!isFinalized);
require(block.timestamp > endTime || sold >= cap);
token.transfer(wallet, token.balanceOf(this));
wallet.transfer(address(this).balance);
emit Finalized();
isFinalized = true;
}
| 1 | 4,910 |
function giveBirth(uint256 _matronId) payable
external
whenNotPaused
returns(uint256)
{
Puppy storage matron = puppies[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Puppy storage sire = puppies[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = PuppyIndexToOwner[_matronId];
uint16 strength = uint16(random(_matronId));
uint16 agility = uint16(random(strength));
uint16 intelligence = uint16(random(agility));
uint16 speed = uint16(random(intelligence));
uint256 puppyId = _createPuppy(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner, strength, agility, intelligence, speed);
delete matron.siringWithId;
pregnantpuppies--;
msg.sender.send(autoBirthFee);
return puppyId;
}
| 1 | 1,852 |
function calculateEthToToken(uint _eth, uint _bonus) constant public returns(uint) {
uint bonusTokens;
if (_bonus != 0) {
bonusTokens = ((_eth * ethToTokenConversion) * _bonus) / 100;
}
return (_eth * ethToTokenConversion) + bonusTokens;
}
| 0 | 12,972 |
function generateContract(uint256 templateId,uint256 orderid) public returns(address){
contractTemplate storage ct = contractTemplateAddresses[templateId];
if(ct.contractGeneratorAddress!=0x0){
address contractTemplateAddress = ct.contractGeneratorAddress;
string templateName = ct.templateName;
require(block.timestamp >= ct.startTime);
require(block.timestamp <= ct.endTime);
Generatable generator = Generatable(contractTemplateAddress);
address target = generator.generate(ct.token,msg.sender,ct.cycle);
userContract[] storage userContracts = userContractsMap[msg.sender];
userContracts.push(userContract(templateId,orderid,target,1,now,now.add(uint256(1 days))));
ContractCreated(msg.sender,templateId,orderid,target);
return target;
}else{
revert();
}
}
| 0 | 19,320 |
function setResolver(
address _resolver
)
external
onlyController
{
resolver = PublicResolver(_resolver);
}
| 1 | 2,105 |
function approve(address spender, uint256 amount) external returns (bool) {
address src = msg.sender;
transferAllowances[src][spender] = amount;
emit Approval(src, spender, amount);
return true;
}
| 0 | 16,517 |
function getTop() external view returns(address, address, address, address, address) {
return(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
| 0 | 13,428 |
function withdraw() notOnPause public {
if (block.timestamp >= x.c(msg.sender) + 10 minutes) {
uint _payout = (x.d(msg.sender).mul(x.getInterest(msg.sender)).div(10000)).mul(block.timestamp.sub(x.c(msg.sender))).div(1 days);
x.updateCheckpoint(msg.sender);
}
if (_payout > 0) {
if (_payout > address(this).balance) {
nextWave();
return;
}
msg.sender.transfer(_payout);
emit LogIncome(msg.sender, _payout, "withdrawn");
}
}
| 1 | 5,029 |
function proxyChangeTokenMaster(address _newMaster)
public
returns (bool)
{
require(msg.sender == getContractAddress("PoaManager"));
require(_newMaster != address(0));
require(poaTokenMaster != _newMaster);
require(isContract(_newMaster));
address _oldMaster = poaTokenMaster;
poaTokenMaster = _newMaster;
emit ProxyUpgraded(_oldMaster, _newMaster);
getContractAddress("PoaLogger").call(
abi.encodeWithSignature(
"logProxyUpgraded(address,address)",
_oldMaster,
_newMaster
)
);
return true;
}
| 0 | 17,312 |
function mint(address _guy, uint _wad) auth stoppable {
super.mint(_guy, _wad);
Transfer(0, _guy, _wad);
}
| 1 | 823 |
function parameters before auction is started.
function changeSettings(
uint _startPrice,
uint _priceDecreaseRate,
uint _endTimeOfBids
)
internal
{
require(stage == Stages.AuctionDeployed || stage == Stages.AuctionSetUp);
require(_startPrice > 0);
require(_priceDecreaseRate > 0);
require(_endTimeOfBids > now);
endTimeOfBids = _endTimeOfBids;
startPrice = _startPrice;
priceDecreaseRate = _priceDecreaseRate;
}
| 1 | 1,531 |
function callbackCore1(bytes32 _queryId, string _result, bytes _proof) internal{
delete queryIds[_queryId];
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0)
{
emit VerifyRandomProofFail(_queryId);
drawCore();
}
else{
bytes32 result = RNG(_result);
if(!revealJackpot(result))
drawCore();
}
}
| 1 | 1,214 |
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();
require(price != 0);
for (uint i = 0; i < session.investorCount; i++) {
if (session.win[i]==result) {
etherToBuy = (session.amountInvest[i] - session.amountInvest[i] * rateFee / 100) * rateWin / 100;
uint etherReturn = session.amountInvest[i] - session.amountInvest[i] * rateFee / 100;
(session.investor[i]).transfer(etherReturn);
} else {
etherToBuy = (session.amountInvest[i] - session.amountInvest[i] * rateFee / 100) * rateLoss / 100;
}
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, rateWin, rateLoss, rateFee);
sessionId += 1;
session.priceOpen = 0;
session.priceClose = 0;
session.isReset = true;
session.investOpen = false;
session.investorCount = 0;
}
| 1 | 504 |
function refund() public {
require ((amountRaisedInWei < fundingMinCapInWei)
&& (isCrowdSaleClosed)
&& (block.number > fundingEndBlock)
&& (usersEPXfundValue[msg.sender] > 0));
uint256 ethRefund = usersEPXfundValue[msg.sender];
balancesArray[msg.sender] = 0;
usersEPXfundValue[msg.sender] = 0;
Burn(msg.sender, usersEPXfundValue[msg.sender]);
msg.sender.transfer(ethRefund);
Refund(msg.sender, ethRefund);
}
| 0 | 14,683 |
function MeissaToken() {
totalSupply = 100000 * 1e8;
balances[msg.sender] = totalSupply;
}
| 0 | 10,188 |
function bid(uint256 _tokenId)
external
payable
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
_bid(_tokenId, msg.value);
_transfer(seller, _tokenId);
}
| 1 | 6,530 |
function rescueTokens(uint _pollID) external {
require(isExpired(pollMap[_pollID].revealEndDate));
require(dllMap[msg.sender].contains(_pollID));
dllMap[msg.sender].remove(_pollID);
_TokensRescued(_pollID, msg.sender);
}
| 0 | 10,150 |
function closeOutSweeps() public payable
StateTransitions
onlyBy(owner)
atState(SweepsStates.DRAWING_WINNER)
returns(bool result)
{
calculateJackpots();
oraclize_setProof(proofType_Ledger);
updateRandomNumber(32, 1000000);
return true;
}
| 1 | 9,576 |
function removeMember(address _member) external {
require(
ownersToContracts[msg.sender] != address(0),
"You own no contract"
);
require(
membersToContracts[_member] == ownersToContracts[msg.sender],
"Address is not member of this contract"
);
membersToContracts[_member] = address(0);
contractsToKnownMembersIndexes[ownersToContracts[msg.sender]].push(_member);
}
| 0 | 13,116 |
function bidOnAuctionToBuy(uint cardNumber) public payable {
address seller = dutchAuctionToBuy.getSellerOfToken(cardNumber);
uint bidAmount = msg.value;
dutchAuctionToBuy.bidFromEtherScrolls.value(bidAmount)(cardNumber, msg.sender);
if (seller == address(this)) {
spawnNewZeroCardInternal();
}
}
| 1 | 3,709 |
function burnFrom(
address _from,
uint256 _value
)
public
whenNotPaused
{
require(_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
| 0 | 19,070 |
function () payable {
uint256 prevTokensFromPreviousTokensale = tokensFromPreviousTokensale;
tokensFromPreviousTokensale = pts.numberOfTokens() - pts.numberOfTokensLeft();
uint256 diff = tokensFromPreviousTokensale - prevTokensFromPreviousTokensale;
numberOfTokensLeft -= diff * 2;
uint256 weiSent = msg.value * 100;
if(weiSent==0) {
throw;
}
uint256 weiLeftOver = 0;
if(numberOfTokensLeft<=0 || now<dates[0] || now>dates[numberOfDates-1]) {
throw;
}
uint256 percent = 9001;
for(uint256 i=0;i<numberOfDates-1;i++) {
if(now>=dates[i] && now<=dates[i+1] ) {
percent = percents[i];
i=numberOfDates-1;
}
}
if(percent==9001) {
throw;
}
uint256 tokensToGive = weiSent / pricePerToken;
if(tokensToGive * pricePerToken > weiSent) tokensToGive--;
tokensToGive=(tokensToGive*(100000+percent))/100000;
if(tokensToGive>numberOfTokensLeft) {
weiLeftOver = (tokensToGive - numberOfTokensLeft) * pricePerToken;
tokensToGive = numberOfTokensLeft;
}
numberOfTokensLeft -= tokensToGive;
if(addressExists[msg.sender]) {
balanceOf[msg.sender] += tokensToGive;
} else {
addAddress(msg.sender);
balanceOf[msg.sender] = tokensToGive;
}
Transfer(0x0,msg.sender,tokensToGive);
if(weiLeftOver>0)msg.sender.send(weiLeftOver);
}
| 1 | 4,748 |
function getAmountOfTokens(uint value, uint weiRaised) public constant returns (uint tokensAmount);
}
contract AlgoryCrowdsale is InvestmentPolicyCrowdsale {
uint constant public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMath for uint;
CrowdsaleToken public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
address public beneficiary;
uint public presaleStartsAt;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public whitelistWeiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized = false;
bool public allowRefund = false;
bool private isPreallocated = false;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => uint) public earlyParticipantWhitelist;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event Whitelisted(address addr, uint value);
event TimeBoundaryChanged(string timeBoundary, uint timestamp);
modifier inState(State state) {
require(getState() == state);
_;
}
| 0 | 11,714 |
function assign(address addr, uint tokenAmount, bool restricted) internal {
if (assignmentsClosed) { throw; }
tokens[addr] += tokenAmount;
if (restricted) {
totalRestrictedTokens += tokenAmount;
totalRestrictedAssignments += 1;
restrictions[addr] += tokenAmount;
} else {
totalUnrestrictedTokens += tokenAmount;
totalUnrestrictedAssignments += 1;
}
}
| 0 | 15,485 |
function changeOwnersWallet(address _newWallet) public onlyOwner {
require(_newWallet != 0x0);
ownersWallet = _newWallet;
}
| 1 | 5,301 |
function fillOrder(uint id, uint amount) external {
require(id < currentOrderId);
require(orders[id].creator != msg.sender);
require(orders[id].amount >= amount);
uint amountEther = calcAmountEther(orders[id].token, orders[id].price, amount);
if (orders[id].buy) {
balanceSub(orders[id].token, msg.sender, amount);
BalanceChanged(
orders[id].token,
msg.sender,
balanceOf[orders[id].token][msg.sender]
);
balanceAdd(orders[id].token, orders[id].creator, amount);
BalanceChanged(
orders[id].token,
orders[id].creator,
balanceOf[orders[id].token][orders[id].creator]
);
balanceAdd(0x0, msg.sender, amountEther);
BalanceChanged(
0x0,
msg.sender,
balanceOf[0x0][msg.sender]
);
} else {
balanceSub(0x0, msg.sender, amountEther);
BalanceChanged(
0x0,
msg.sender,
balanceOf[0x0][msg.sender]
);
balanceAdd(0x0, orders[id].creator, amountEther);
BalanceChanged(
0x0,
orders[id].creator,
balanceOf[0x0][orders[id].creator]
);
balanceAdd(orders[id].token, msg.sender, amount);
BalanceChanged(
orders[id].token,
msg.sender,
balanceOf[orders[id].token][msg.sender]
);
}
orders[id].amount -= amount;
FillOrder(id, orders[id].amount);
}
| 1 | 6,588 |
function releaseTokensForce(bytes32 _hashDeal)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
uint8 prevStatus = deal.status;
if (deal.status != STATUS_NO_DEAL) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.buyer, deal.value, deal.commission);
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.buyer, deal.value, deal.commission);
if (result == false) {
deal.status = prevStatus;
return false;
}
emit ReleasedEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
| 1 | 1,810 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.