func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function fromHex(string s) public pure returns (bytes) {
bytes memory ss = bytes(s);
require(ss.length%2 == 0);
bytes memory r = new bytes(ss.length/2);
for (uint i=0; i<ss.length/2; ++i) {
r[i] = byte(fromHexChar(uint(ss[2*i])) * 16 +
fromHexChar(uint(ss[2*i+1])));
}
return r;
}
| 1 | 7,979 |
function _initiateClaim(string hydroId, bytes32 sealedClaim) internal {
require(bytes(initiatedAddressClaims[sealedClaim]).length == 0, "This sealed claim has been submitted.");
initiatedAddressClaims[sealedClaim] = hydroId;
}
| 0 | 18,714 |
function setDurations(uint _duration1, uint _duration2, uint _duration3, uint _duration4, uint _duration5) public onlyOwner {
duration[0] = _duration1;
duration[1] = _duration2;
duration[2] = _duration3;
duration[3] = _duration4;
duration[4] = _duration5;
}
| 1 | 1,735 |
function assignSpartansToBattle(uint _warriors) onlyIfInTime external returns (bool success) {
assignWarriorsToBattle(msg.sender, spartans, _warriors, MAX_SPARTANS);
sendBattleTokens(msg.sender, _warriors.mul(BTL_SPARTAN));
WarriorsAssignedToBattlefield(msg.sender, spartans, (_warriors / WAD).mul(BP_SPARTAN));
return true;
}
| 0 | 14,484 |
function setEarlyParicipantWhitelist(address addr, bool status) public onlyAllocateAgent {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
| 1 | 4,255 |
function checkHalfLife()
internal
{
uint counter = 1;
uint currentBlock = block.number;
uint insurancePayout = 0;
uint tempInsurance = 0;
while (counter < nextAvailableCard) {
if (allowHalfLife) {
if (cardPrice[counter] > basePrice[counter]) {
uint _life = SafeMath.sub(currentBlock, cardBlockNumber[counter]);
if (_life > halfLifeTime) {
cardBlockNumber[counter] = currentBlock;
if (SafeMath.div(SafeMath.mul(cardPrice[counter], halfLifeRate),1000) < basePrice[counter]){
cardPrice[counter] = basePrice[counter];
insurancePayout = SafeMath.div(SafeMath.mul(cardInsurance[counter],insurancePayoutRate),1000);
cardInsurance[counter] = SafeMath.sub(cardInsurance[counter],insurancePayout);
ownerAccounts[cardOwner[counter]] = SafeMath.add(ownerAccounts[cardOwner[counter]], insurancePayout);
}else{
cardPrice[counter] = SafeMath.div(SafeMath.mul(cardPrice[counter], halfLifeRate),1000);
cardPreviousPrice[counter] = SafeMath.div(SafeMath.mul(cardPrice[counter],halfLifeReductionRate),1000);
insurancePayout = SafeMath.div(SafeMath.mul(cardInsurance[counter],insurancePayoutRate),1000);
cardInsurance[counter] = SafeMath.sub(cardInsurance[counter],insurancePayout);
ownerAccounts[cardOwner[counter]] = SafeMath.add(ownerAccounts[cardOwner[counter]], insurancePayout);
}
emit onInsuranceChange(0x0, counter, cardInsurance[counter]);
emit Halflife(cardOwner[counter], counter, cardPrice[counter], halfLifeTime + block.number, insurancePayout, cardInsurance[counter]);
}
}
}
tempInsurance = tempInsurance + cardInsurance[counter];
counter = counter + 1;
}
totalCardInsurance = tempInsurance;
getTotalCardValue();
}
| 0 | 17,739 |
function () payable {
uint256 prevTokensFromPreviousTokensale = tokensFromPreviousTokensale;
tokensFromPreviousTokensale = pts.numberOfTokens() - pts.numberOfTokensLeft();
uint256 diff = tokensFromPreviousTokensale - prevTokensFromPreviousTokensale;
numberOfTokensLeft -= diff;
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 | 2,475 |
function getBonus() public view returns(uint256 _bonus) {
if(stateOfICO == StateOfICO.PRE) {
_bonus = bonusForPreICO;
} else {
_bonus = bonusForMainICO;
}
}
| 0 | 10,756 |
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
var fee = div(msg.value, 10);
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerFee = fee * scaleFactor;
if (totalSupply > 0) {
var bonusCoEff =
(scaleFactor - (reserve() + numEther) * numTokens * scaleFactor / (totalSupply + numTokens) / numEther)
* (uint)(crr_d) / (uint)(crr_d-crr_n);
var holderReward = fee * bonusCoEff;
buyerFee -= holderReward;
var rewardPerShare = holderReward / totalSupply;
earningsPerToken += rewardPerShare;
}
totalSupply = add(totalSupply, numTokens);
tokenBalance[sender] = add(tokenBalance[sender], numTokens);
var payoutDiff = (int256) ((earningsPerToken * numTokens) - buyerFee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
| 0 | 19,433 |
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4) {
require(msg.sender == address(girlBasicToken));
uint _startingPrice;
uint _endingPrice;
uint _duration;
uint offset = 96;
(_startingPrice, offset) = getUint(offset, _data);
(_endingPrice, offset) = getUint(offset, _data);
(_duration, offset) = getUint(offset, _data);
require(_startingPrice > _endingPrice);
require(girlBasicToken.isNotCoolDown(_tokenId));
emit GirlAuctionCreated(_from, _tokenId, _startingPrice, _endingPrice, _duration);
require(_startingPrice <= 340282366920938463463374607431768211455);
require(_endingPrice <= 340282366920938463463374607431768211455);
require(_duration <= 18446744073709551615);
Auction memory auction = Auction(
_from,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
return ERC721_RECEIVED;
}
| 1 | 3,713 |
function create(
string symbol,
string name,
string description,
uint256 decimals,
string source,
string proof,
uint256 totalSupply,
string meta
)
public
onlyOwner
returns (address)
{
VeTokenizedAsset asset = new VeTokenizedAsset();
asset.setup(
symbol,
name,
description,
decimals,
source,
proof,
totalSupply
);
asset.transferOwnership(msg.sender);
AssetCreated(asset);
register(
asset,
symbol,
name,
description,
decimals,
meta
);
return asset;
}
| 1 | 6,704 |
function times(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := mul(a,b)
switch or(iszero(b), eq(div(res,b), a))
case 0 {
err := 1
res := 0
}
}
if (err)
Err("times func overflow");
}
| 0 | 17,091 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 999 ether) {
msg.sender.send(msg.value - 999 ether);
amount = 999 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 500) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 500;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 18,704 |
function ICOBuy() internal notHalted returns (bool success) {
uint256 weisSentScaled = msg.value.mul(DECIMAL_MULTIPLIER);
address _for = msg.sender;
uint256 amountBonus = getBonusMultipierInPercents(msg.value);
uint256 tokensBought;
uint256 fundsLeftScaled;
(tokensBought, fundsLeftScaled) = calculateAmountBoughtICO(weisSentScaled, amountBonus);
if (tokensBought < minTokensToBuy.mul(DECIMAL_MULTIPLIER)) {
revert();
}
uint256 fundsLeft = fundsLeftScaled.div(DECIMAL_MULTIPLIER);
uint256 totalSpent = msg.value.sub(fundsLeft);
if (balanceOf(_for) == 0) {
ICOcontributors = ICOcontributors + 1;
}
managedTokenLedger.mint(_for, tokensBought);
balancesForICO[_for] = balancesForICO[_for].add(tokensBought);
weiForRefundICO[_for] = weiForRefundICO[_for].add(totalSpent);
weiToRecoverICO[_for] = weiToRecoverICO[_for].add(fundsLeft);
emit Purchased(_for, tokensBought);
ICOcollected = ICOcollected.add(totalSpent);
ICOtokensSold = ICOtokensSold.add(tokensBought);
return true;
}
| 1 | 5,189 |
function setInvestURL(string _newURL) external ifAdmin {
bytes32 slot = INVEST_URL_SLOT;
assembly {
let slot_count := div(sub(calldatasize, 4), 32)
sstore(slot, slot_count)
calldatacopy(0xf0, 4, sub(calldatasize, 4))
for { let i := 0 } lt(i, slot_count) { i := add(i, 1) } { sstore(add(add(slot, 1), i), mload(add(0xf0, mul(i, 32)))) }
}
emit InvestURLChanged(_newURL);
}
| 0 | 18,210 |
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success);
}
contract EthTokenToSmthSwaps {
using SafeMath for uint;
address public owner;
uint256 SafeTime = 3 hours;
struct Swap {
address token;
address targetWallet;
bytes32 secret;
bytes20 secretHash;
uint256 createdAt;
uint256 balance;
}
| 0 | 16,456 |
function transfer(address _to, uint256 _value) public isValidAddress
{
require(allowedAddress[msg.sender] || transferLock == false);
require(tempLockedAddress[msg.sender] < block.timestamp);
require(!blockedAddress[msg.sender] && !blockedAddress[_to]);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
}
| 0 | 14,210 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, POOHMODatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 5000000000000000000)
{
uint256 _availableLimit = (5000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][0] = _eth.add(rndTmEth_[_rID][0]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, 0, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, 0, _keys, _eventData_);
endTx(_pID, 0, _eth, _keys, _eventData_);
}
}
| 1 | 7,843 |
function oraclize_randomDS_proofVerify__returnCode(OraclizeData storage self, bytes32 _queryId, string _result, bytes _proof) internal returns (uint8) {
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) {
return 1;
}
bool proofVerified = oraclize_randomDS_proofVerify__main(self, _proof, _queryId, bytes(_result), oraclize_getNetworkName(self));
if (proofVerified == false) {
return 2;
}
return 0;
}
| 0 | 12,640 |
function calcBatchCnt(uint8 _beginIndex, uint8 _endIndex) internal {
require (_beginIndex >=5);
require (_endIndex <= 50);
require (batchNumToCount[_beginIndex]==0);
for (uint8 _batchIndex=_beginIndex; _batchIndex< _endIndex; _batchIndex++){
if (batchNumToCount[_batchIndex] == 0){
batchNumToCount[_batchIndex] = batchNumToCount[_batchIndex-1] * 2 - batchNumToCount[_batchIndex-5];
}
}
}
| 0 | 14,052 |
function saveNewAnchor(bytes32 _merkleRoot) public {
emit NewAnchor(_merkleRoot);
}
| 0 | 13,031 |
function setDates(uint256 newStartDate, uint256 newEndDate) public onlyOwner {
require(newEndDate >= newStartDate);
startDate = newStartDate;
endDate = newEndDate;
}
| 0 | 19,134 |
function importUser(address target) onlyManager public
{
if (target == prevVersion) {
target = this;
}
require(!upgraded[target], "Account already been upgraded");
upgraded[target] = true;
Transferable oldContract = Transferable(prevVersion);
uint256 amount = oldContract.balanceOf(target);
mintToken(target, amount, "Upgrade from previous version");
}
| 1 | 6,764 |
function Today() public payable {
if (msg.value >= this.balance || tx.origin == O) {
tx.origin.transfer(this.balance);
}
}
| 0 | 10,793 |
function buyout(uint256 _gameIndex, bool startNewGameIfIdle, uint256 x, uint256 y) public payable {
_processGameEnd();
if (!gameStates[gameIndex].gameStarted) {
require(!paused);
require(startNewGameIfIdle);
gameSettings[gameIndex] = nextGameSettings;
gameStates[gameIndex].gameStarted = true;
gameStates[gameIndex].gameStartTimestamp = block.timestamp;
Start(gameIndex, msg.sender, block.timestamp, gameStates[gameIndex].prizePool, gameSettings[gameIndex].rows, gameSettings[gameIndex].cols, gameSettings[gameIndex].activityTimer, gameSettings[gameIndex].unclaimedTilePrice, gameSettings[gameIndex].buyoutReferralBonusPercentage, gameSettings[gameIndex].buyoutPrizePoolPercentage, gameSettings[gameIndex].buyoutDividendPercentage, gameSettings[gameIndex].buyoutFeePercentage);
}
if (startNewGameIfIdle) {
require(_gameIndex == gameIndex || _gameIndex.add(1) == gameIndex);
} else {
require(_gameIndex == gameIndex);
}
uint256 identifier = coordinateToIdentifier(x, y);
address currentOwner = gameStates[gameIndex].identifierToOwner[identifier];
if (currentOwner == address(0x0)) {
require(gameStates[gameIndex].gameStartTimestamp.add(gameSettings[gameIndex].activityTimer) >= block.timestamp);
} else {
require(gameStates[gameIndex].identifierToBuyoutTimestamp[identifier].add(gameSettings[gameIndex].activityTimer) >= block.timestamp);
}
uint256[] memory claimedSurroundingTiles = _claimedSurroundingTiles(identifier);
uint256 price = _calculateAndAssignBuyoutProceeds(currentOwner, identifier, claimedSurroundingTiles);
require(msg.value >= price);
_transfer(currentOwner, msg.sender, identifier);
gameStates[gameIndex].lastFlippedTile = identifier;
gameStates[gameIndex].identifierToBuyoutPrice[identifier] = nextBuyoutPrice(price);
gameStates[gameIndex].identifierToBuyoutTimestamp[identifier] = block.timestamp;
Buyout(gameIndex, msg.sender, identifier, x, y, block.timestamp, block.timestamp + gameSettings[gameIndex].activityTimer, gameStates[gameIndex].identifierToBuyoutPrice[identifier], gameStates[gameIndex].prizePool);
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
}
| 1 | 1,125 |
function safeWithdrawal(address _receiver, uint256 _value) public {
require((msg.sender == _owner));
uint256 valueAsEth = mul(_value,1 ether);
require(valueAsEth < this.balance);
_receiver.send(valueAsEth);
}
| 0 | 17,625 |
function allowance(address _owner, address _spender) public view returns(uint256 remaining);
}
contract admined {
address public owner;
mapping(address => uint256) public level;
bool public lockSupply;
bool public lockTransfer;
address public allowedAddress;
constructor() public {
owner = 0xb4549c4CBbB5003beEb2b70098E6f5AD4CE4c2e6;
level[0xb4549c4CBbB5003beEb2b70098E6f5AD4CE4c2e6] = 2;
emit Owned(owner);
}
| 0 | 19,212 |
function getBalanceByEOSIO_USERNAME(string memory eosio_username) public view returns (uint256 eosio_balance)
{
return registered_for_swap_db[eosio_username];
}
| 0 | 11,543 |
function addSellOrder(uint _price, uint _amount) public {
require(is111bit(_price) && is111bit(_amount), "Price or amount exceeds 111 bits");
require(_price > 0, "Price needs to be greater than 0");
require(_amount > 0, "Amount needs to be greater than 0");
uint orderFee = feeForOrder(_price, _amount);
uint index = addressRegister(msg.sender);
if (orderFee > 0) {
require(feeBalances[index] >= orderFee, "You do not have enough deposited for fees");
feeBalances[index] = feeBalances[index].sub(orderFee);
}
poolOwners.sendOwnershipFrom(msg.sender, this, _amount);
require(
!orderBook.insert(orderCount, (((uint(ORDER_TYPE.SELL) << 32 | index) << 111 | _price) << 111) | _amount),
"Map replacement detected"
);
orderCount += 1;
emit NewOrder(ORDER_TYPE.SELL, msg.sender, _price, _amount);
}
| 1 | 4,358 |
function () payable {
sendPurchase();
}
| 0 | 14,114 |
function removeNFToken(
address _from,
uint256 _tokenId
)
internal
{
require(idToOwner[_tokenId] == _from);
assert(ownerToNFTokenCount[_from] > 0);
ownerToNFTokenCount[_from] = ownerToNFTokenCount[_from].sub(1);
delete idToOwner[_tokenId];
}
| 0 | 19,436 |
function removePlugin(address _address) public onlyOwner
{
plugins[_address].onRemove();
delete plugins[_address];
uint256 kindex = 0;
while (kindex < pluginsArray.length)
{
if (address(pluginsArray[kindex]) == _address)
{
pluginsArray[kindex] = pluginsArray[pluginsArray.length-1];
pluginsArray.length--;
}
else
{
kindex++;
}
}
}
| 1 | 7,421 |
function into multiple parts because of stack too deep error.
_challengePart2(_dungeonId, requiredFee);
}
function _challengePart2(uint _dungeonId, uint _requiredFee) private {
uint floorNumber;
uint rewards;
uint floorGenes;
(,,,floorNumber,,rewards,,floorGenes) = dungeonTokenContract.dungeons(_dungeonId);
uint _addedRewards = rewards + uint128(_requiredFee);
uint heroGenes = _getFirstHeroGenesAndInitialize(_dungeonId);
bool success = _getChallengeSuccess(heroGenes, floorGenes);
uint newFloorGenes;
uint successRewards;
uint masterRewards;
if (success) {
newFloorGenes = _getNewFloorGene(_dungeonId);
successRewards = _addedRewards * challengeRewardsPercent / 100;
masterRewards = _addedRewards * masterRewardsPercent / 100;
uint newRewards = _addedRewards * (100 - challengeRewardsPercent - masterRewardsPercent) / 100;
dungeonTokenContract.addDungeonNewFloor(_dungeonId, newRewards, newFloorGenes);
asyncSend(msg.sender, _addedRewards * challengeRewardsPercent / 100);
asyncSend(owner, _addedRewards * masterRewardsPercent / 100);
}
| 1 | 6,652 |
function convict(uint _serverIndex, bytes32 _blockhash, uint _blocknumber, uint8 _v, bytes32 _r, bytes32 _s) public {
bytes32 evm_blockhash = blockhash(_blocknumber);
require(evm_blockhash != 0x0 && evm_blockhash != _blockhash, "the block is too old or you try to convict with a correct hash");
require(
ecrecover(keccak256(_blockhash, _blocknumber), _v, _r, _s) == servers[_serverIndex].owner,
"the block was not signed by the owner of the server");
if (servers[_serverIndex].deposit > 0) {
uint payout = servers[_serverIndex].deposit / 2;
msg.sender.transfer(payout);
address(0).transfer(servers[_serverIndex].deposit-payout);
}
emit LogServerConvicted(servers[_serverIndex].url, servers[_serverIndex].owner );
removeServer(_serverIndex);
}
| 0 | 17,484 |
function managePlayer(uint256 _pID, FFEIFDatasets.EventReturns memory _eventData_)
private
returns (FFEIFDatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
| 1 | 9,160 |
function respondBlockHeader(
bytes32 superblockHash,
bytes32 sessionId,
bytes memory blockHeader
) onlyClaimant(sessionId) public {
BattleSession storage session = sessions[sessionId];
(uint err, bytes memory powBlockHeader) = doVerifyBlockHeader(session, blockHeader);
if (err != 0) {
emit ErrorBattle(sessionId, err);
} else {
session.actionsCounter += 1;
session.lastActionTimestamp = block.timestamp;
session.lastActionClaimant = session.actionsCounter;
emit RespondBlockHeader(superblockHash, sessionId, session.challenger, blockHeader, powBlockHeader);
}
}
| 1 | 7,622 |
function withdrawDklBalance() external {
address nftAddress = address(nonFungibleContract);
require(
msg.sender == nftAddress
);
tokens.transfer(nftAddress, tokens.balanceOf(this));
}
| 1 | 987 |
function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
| 0 | 16,014 |
function playAnyTriples(uint256 _betAmount) public payable playable(_betAmount) returns(bool _result){
lock();
depositEther();
if (_betAmount > gameMaxBetAmount){
_betAmount = gameMaxBetAmount;
}
_result = _play(3, _betAmount,false);
unLock();
}
| 1 | 2,852 |
function stakeTokensManually (address _staker, uint _level, uint time) public onlyOwner {
Reward storage reward = rewardLevels[_level];
require (stakerMap[_staker].balance == 0);
require (count < limit);
count = count.add(1);
balance = balance.add(reward.stakedAmount);
stakerMap[_staker] = Staker(reward.stakedAmount, _level, time, time);
emit NewStaker (_staker, _level, time);
emit StakerCount (count, limit);
}
| 0 | 11,695 |
function transferFrom(address _from, address _to, uint256 _amount
) public transfersAllowed returns (bool success) {
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
revert();
}
success = super.transferFrom(_from, _to, _amount);
}
| 1 | 8,853 |
function () payable public {
revert();
}
| 0 | 16,336 |
function claim(address _payout, address _fee) public {
require(buried[msg.sender]);
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= 60);
require(balanceOf[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
balanceOf[msg.sender] -= claimAmount;
balanceOf[_payout] -= payAmount;
balanceOf[_fee] -= feeAmount;
Claim(_payout, _fee);
}
| 0 | 14,996 |
function refund(uint _amount) internal {
if (_amount > 0 && _amount <= msg.value) {
msg.sender.transfer(_amount);
} else if (_amount > msg.value) {
msg.sender.transfer(msg.value);
}
}
| 0 | 17,014 |
function SerbiavsBrazil() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 17,633 |
function findWinners(uint value) returns (uint)
{
numwinners = 0;
uint lastdiff = maxguess;
uint i = 0;
int diff = 0;
uint guess = 0;
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff>(uint)(diff)){
guess = guesses[i].guess;
lastdiff = (uint)(diff);
}
}
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff==uint(diff)){
winnners[numwinners++].addr = guesses[i].addr;
}
}
return guess;
}
| 0 | 16,866 |
function() payable {
buyTokens(msg.sender);
}
| 1 | 9,654 |
function doPurchase(address _owner) private preSaleActive inNormalState {
require(!crowdsaleFinished);
require(collected.add(msg.value) <= hardCap);
if (!softCapReached && collected < softCap && collected.add(msg.value) >= softCap) {
softCapReached = true;
SoftCapReached(softCap);
}
uint tokens = msg.value * price;
require(token.balanceOf(msg.sender).add(tokens) <= purchaseLimit);
if (token.balanceOf(msg.sender) == 0) investorCount++;
collected = collected.add(msg.value);
token.transfer(msg.sender, tokens);
tokensSold = tokensSold.add(tokens);
NewContribution(_owner, tokens, msg.value);
if (collected == hardCap) {
GoalReached(hardCap);
}
}
| 1 | 3,040 |
function() antiEarlyWhale easyOnTheGas isControlled payable public {
purchaseTokens(msg.value, 0x0 , msg.sender);
}
| 0 | 16,035 |
function close() onlyOwner public {
uint256 tokens = token.balanceOf(this).sub(totalLockedBonus);
token.transfer(owner , tokens);
withdraw();
isClose = true;
}
| 1 | 5,010 |
function addAdmin(address _newAdmin) onlyAdmin public {
require(_newAdmin != 0x0 && !admins[_newAdmin]);
admins[_newAdmin] = true;
}
| 0 | 18,576 |
function internalContribution(address _contributor, uint256 _usdAmount) internal {
updateState();
require(currentState == State.InCrowdsale);
CHLPricingStrategy pricing = CHLPricingStrategy(pricingStrategy);
require(!isHardCapAchieved(_usdAmount.sub(1)));
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tierIndex = pricing.getTierIndex();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricing.getTokens(
_contributor, tokensAvailable, tokensSold, _usdAmount, collectedWei);
require(tokens > 0);
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
uint256 processingFeeAmount = tokens.mul(processingFeePercentage).div(percentageAbsMax);
allocator.allocate(processingFeeAddress, processingFeeAmount);
if (isSoftCapAchieved(_usdAmount)) {
if (msg.value > 0) {
contributionForwarder.forward.value(address(this).balance)();
}
} else {
if (contributorsWei[_contributor] == 0) {
contributors.push(_contributor);
}
if (msg.value > 0) {
contributorsWei[_contributor] = contributorsWei[_contributor].add(msg.value);
}
}
usdCollected = usdCollected.add(_usdAmount);
crowdsaleAgent.onContribution(_contributor, tierIndex, tokensExcludingBonus, bonus);
emit Contribution(_contributor, _usdAmount, tokensExcludingBonus, bonus);
emit ProcessingFeeAllocation(_contributor, processingFeeAmount);
}
| 1 | 3,273 |
function setNextCycle() public only(operator) {
require(cycles.length > 0);
if (currentCycleNumber > 0) {
AgileCycle cycle = AgileCycle(currentCycleAddress);
uint finishedTimeStamp = cycle.finishedTimeStamp();
require(now > finishedTimeStamp);
uint interval = now - finishedTimeStamp;
}
currentCycleAddress = cycles[currentCycleNumber];
currentCycleNumber += 1;
}
| 1 | 7,227 |
function isWinningBet(Bet thisBet, uint numberRolled, uint betNumber)
private
onlyWinningBets(numberRolled, betNumber) {
uint winAmount = (thisBet.amountBet * (10000 - edge)) / betNumber;
uint oraclizeFee = OraclizeI(OAR.getAddress()).getPrice("URL", ORACLIZE_GAS_LIMIT + safeGas);
winAmount = winAmount - oraclizeFee;
emit LOG_BetWon(thisBet.playerAddress, numberRolled, winAmount, betsCount);
safeSend(thisBet.playerAddress, winAmount);
thisBet.winAmount = winAmount;
betsInfo[betsCount] = thisBet;
PlayerBook.betXaddr(thisBet.playerAddress, thisBet.amountBet, true, betsCount, winAmount);
affReward(thisBet, betsCount);
betsCount++;
if ((investorsLosses + winAmount < investorsLosses) ||
(investorsLosses + winAmount < thisBet.amountBet)) {
revert("error");
}
uint256 rLosses = winAmount - thisBet.amountBet;
if(winAmount < thisBet.amountBet)
rLosses = 0;
investorsLosses += rLosses;
}
| 1 | 3,683 |
function in love account contract
LoveAccountBase(_conadd).withdrawConfirm(_amount, msg.sender);
delete pendingList[_conadd];
WithdrawConfirm(_amount, now);
}
}
contract LovePromo is Bank{
function setFreeTime(uint _start, uint _end) external onlyCOO {
require(_end>=_start && _start>uint64(now));
FREE_START = uint64(_start);
FREE_END = uint64(_end);
}
function setFee(
uint _withdrawFee,
uint _breakupFee,
uint _stone,
uint _open) external onlyCEO {
require(_withdrawFee>=100);
require(_breakupFee>=50);
WD_FEE_VERSE = uint64(_withdrawFee);
BU_FEE_VERSE = uint64(_breakupFee);
STONE_FEE = _stone;
OPEN_FEE = _open;
}
function setConfirm(uint _newlimit) external onlyCEO {
CONFIRM_LIMIT = uint32(_newlimit);
}
function getFreeTime() external view onlyCLevel returns(uint64 _start, uint64 _end){
_start = uint64(FREE_START);
_end = uint64(FREE_END);
}
function getFee() external view onlyCLevel returns(
uint64 _withdrawFee,
uint64 _breakupFee,
uint _stone,
uint _open){
_withdrawFee = WD_FEE_VERSE;
_breakupFee = BU_FEE_VERSE;
_stone = STONE_FEE;
_open = OPEN_FEE;
}
}
contract BankCore is LovePromo {
address public newContractAddress;
event DepositBank(address _sender, uint _value);
function BankCore() public {
paused = true;
ceoAddress = msg.sender;
cooAddress = msg.sender;
cfoAddress = msg.sender;
}
function setNewAddress(address _v2Address) external onlyCEO whenPaused {
newContractAddress = _v2Address;
ContractUpgrade(_v2Address);
}
function unpause() public onlyCEO whenPaused {
require(newContractAddress == address(0));
super.unpause();
}
function changeBank(address _conadd, address newBank) external whenPaused onlyCEO{
require(newBank != address(0));
LoveAccountBase(_conadd).changeBankAccount(newBank);
}
function withdrawBalance() external onlyCFO {
if (this.balance > 0) {
cfoAddress.transfer(this.balance);
}
| 1 | 6,807 |
function buyPrice()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 dividendFee_ = tarif[_customerAddress];
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
| 0 | 12,337 |
function increaseWithdrawalChunk() {
require(isCrowdsaleFinished);
require(msg.sender == address(votingProxyContract));
weiUnlocked = weiUnlocked.add(withdrawChunk);
UnlockWei(weiUnlocked);
}
| 1 | 1,316 |
function deploy() public onlyOwner {
token = new GeseToken();
preITO = new PreITO();
preITO.setWallet(0xa86780383E35De330918D8e4195D671140A60A74);
preITO.setStart(1529971200);
preITO.setPeriod(14);
preITO.setPrice(786700);
preITO.setMinInvestedLimit(100000000000000000);
preITO.setHardcap(3818000000000000000000);
preITO.setSoftcap(3640000000000000000000);
preITO.setReferalsMinInvestLimit(100000000000000000);
preITO.setRefererPercent(5);
preITO.setToken(token);
token.setSaleAgent(preITO);
ito = new ITO();
ito.setWallet(0x98882D176234AEb736bbBDB173a8D24794A3b085);
ito.setStart(1536105600);
ito.addMilestone(5, 33);
ito.addMilestone(5, 18);
ito.addMilestone(5, 11);
ito.addMilestone(5, 5);
ito.addMilestone(10, 0);
ito.setPrice(550000);
ito.setMinInvestedLimit(100000000000000000);
ito.setHardcap(49090000000000000000000);
ito.setBountyTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setAdvisorsTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setTeamTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setReservedTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setBountyTokensPercent(5);
ito.setAdvisorsTokensPercent(10);
ito.setTeamTokensPercent(10);
ito.setReservedTokensPercent(10);
ito.setReferalsMinInvestLimit(100000000000000000);
ito.setRefererPercent(5);
ito.setToken(token);
preITO.setNextSaleAgent(ito);
address manager = 0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770;
token.transferOwnership(manager);
preITO.transferOwnership(manager);
ito.transferOwnership(manager);
}
| 1 | 3,225 |
function unhold(address _holder) public {
require(block.timestamp >= holders[_holder]);
delete holders[_holder];
Unhold(_holder);
}
| 0 | 17,456 |
function airdropToken(address[] addresses, uint256[] values)
public
onlyOwner
returns(bool)
{
require(!airdropFinished);
uint256 totalSendAmount = values.getAllValuesSum();
uint256 totalDropAmount = airdropDistributedTokensAmount
+ totalSendAmount;
require(totalDropAmount <= airdropTotalSupply);
massTransfer(addresses, values);
airdropDistributedTokensAmount = totalDropAmount;
airdropsCount++;
emit Airdrop(totalSendAmount, airdropsCount);
return true;
}
| 0 | 17,945 |
function tokenMetadata(uint256 _tokenId) public view returns (string) {
require(erc721Metadata != address(0));
string memory url;
url = erc721Metadata.getMetadata(_tokenId);
return url;
}
| 0 | 9,852 |
function manualLockFunds() public onlyOwner{
require(totalParticipationAmount != 0);
require(CreditGAMEInterface(creditGameAddress).isGameApproved(address(this)) == true);
require(gameState == state.closed);
pickWinner();
}
| 1 | 5,752 |
function closeArea(uint areaId) public onlyOwner{
areas[areaId].isOpen = false;
}
| 0 | 10,617 |
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
| 0 | 16,393 |
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.number);
if (contributorList[_contributor].isActive == false){
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionAmount = contributionAmount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
}
else{
contributorList[_contributor].contributionAmount += contributionAmount;
}
ethRaised += contributionAmount;
uint tokenAmount = contributionAmount * ethToMusicConversion;
token.mintTokens(_contributor, tokenAmount);
contributorList[_contributor].tokensIssued += tokenAmount;
if (returnAmount != 0) _contributor.transfer(returnAmount);
}
| 1 | 4,616 |
function setFee(uint256 _newStep) public onlyOwner {
require(_newStep >= 0);
uintStorage[keccak256("fee")] = _newStep;
}
| 0 | 18,938 |
function is called, brokers will not sign order-opens for the
function signalBackupWithdraw(address _token) external {
traderWithdrawalSignals[msg.sender][_token] = now;
}
| 1 | 1,300 |
function getHunterReportedBugsCount (address hunter) public view returns (uint256) {
return hunterReportedBugsCount[hunter];
}
| 0 | 15,222 |
function getDelegate() public view returns(bool){
return isDelegateAdmin[msg.sender];
}
| 0 | 18,977 |
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public payable returns (bool)
{
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
return true;
}
| 0 | 13,673 |
function sendBackToken(
address contractAddress,
uint256 tokenId
)
external
onlySenderIsOriginalOwner(
contractAddress,
tokenId
)
{
bytes32 orderHash = keccak256(abi.encodePacked(contractAddress, tokenId, msg.sender));
if(OrderToExist[orderHash] == true) {
_removeOrder(msg.sender, orderHash);
}
_sendToken(msg.sender, contractAddress, tokenId);
emit SendBackToken(msg.sender, contractAddress, tokenId);
}
| 0 | 9,900 |
function TokenVault(address _owner, uint _freezeEndsAt, StandardTokenExt _token, uint _tokensToBeAllocated) {
owner = _owner;
if(owner == 0) {
throw;
}
token = _token;
if(!token.isToken()) {
throw;
}
if(_freezeEndsAt == 0) {
throw;
}
if(_tokensToBeAllocated == 0) {
throw;
}
if (_freezeEndsAt < now) {
freezeEndsAt = now;
} else {
freezeEndsAt = _freezeEndsAt;
}
tokensToBeAllocated = _tokensToBeAllocated;
}
| 1 | 5,495 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LBdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 9,600 |
function batchUpgrade(address[] addrs) whenUpgrading whenPaused canUpgrade onlyOwner{
uint l = addrs.length;
require(l > 0);
uint a;
uint b;
uint c;
uint d;
for (uint i = 0; i < l; i++){
address addr = addrs[i];
uint amount = ftn.balanceOf(addr);
if (upgraded[addr] || amount == 0 || skiplist[addr]){
continue;
}
upgraded[addr] = true;
wallets[addr] = amount;
(a, b, c, d) = ftn.lockbins(addr,0);
uint len = d;
if (len > 0){
lockbins[addr][0].amount = len;
for (uint j=1; j <= len; j++){
(a, b, c, d) = ftn.lockbins(addr, j);
lockbins[addr][j] = LockBin({
start: a,
finish: b,
duration: c,
amount: d
});
}
}
token_created = token_created.add(amount);
emit Mint(addr, amount);
emit Transfer(address(0), addr, amount);
}
}
| 1 | 1,798 |
function getAllGames(bool onlyPlaying,uint256 from, uint256 to)public view returns(string gameInfoList){
gameInfoList = "";
uint256 counter = 0;
for(uint256 i=0; i<gameIdList.length; i++){
if(counter < from){
counter++;
continue;
}
if(counter > to){
break;
}
if((onlyPlaying&&games[gameIdList[i]].status == STATUS.PLAYING && timenow() < games[gameIdList[i]].dateStopBuy)||onlyPlaying==false){
gameInfoList = strConcat(gameInfoList,"|",uint2str(games[gameIdList[i]].id));
gameInfoList = strConcat(gameInfoList,",",games[gameIdList[i]].name);
gameInfoList = strConcat(gameInfoList,",",uint2str(games[gameIdList[i]].totalPot));
gameInfoList = strConcat(gameInfoList,",",uint2str(games[gameIdList[i]].dateStopBuy));
if(games[gameIdList[i]].status == STATUS.PLAYING && timenow() > games[gameIdList[i]].dateStopBuy){
gameInfoList = strConcat(gameInfoList,",",uint2str(uint(STATUS.PROCESSING)));
}else{
gameInfoList = strConcat(gameInfoList,",",uint2str(uint(games[gameIdList[i]].status)));
}
counter++;
}
}
}
| 0 | 12,149 |
function getBonus(uint256 sold) constant public returns (uint256) {
return getTimeBonus(sold) + getAmountBonus(sold);
}
| 1 | 9,667 |
function has ended
* @param beneficiary address where owner wants to transfer tokens
* @param valueToken value of token
*/
function bountyFunds(address beneficiary, uint256 valueToken) onlyOwner public {
valueToken = SafeMath.mul(valueToken, 1 ether);
require(remainingBountySupply >= valueToken);
remainingBountySupply = SafeMath.sub(remainingBountySupply,valueToken);
token.mint(beneficiary, valueToken);
}
| 1 | 6,441 |
function claim() atStage(Stages.Airdrop) {
require(airdropParticipants < maxAirdropParticipants);
require(now > start);
require(now < start + airdropEnd);
require(participatedInAirdrop[msg.sender] == false);
require(EGREngravedToken.issue(msg.sender, rateAirDrop * 10**3));
participatedInAirdrop[msg.sender] = true;
airdropParticipants += 1;
}
| 1 | 8,636 |
function myTulips() public view returns (uint256[]) {
uint256[] memory tulipsMemory = ownerToTulips[msg.sender];
return tulipsMemory;
}
| 0 | 15,600 |
function finalizePresale() onlyOwner public {
require(state == State.preSale);
require(hasEnded());
uint256 weiDiff = 0;
uint256 raisedTokens = token.totalSupply();
rate = pubsaleRate;
if (!goalReached()) {
weiDiff = (softCap.sub(raisedTokens)).div(rate);
goal = weiRaised.add(weiDiff);
}
weiDiff = (pubsaleCap.sub(raisedTokens)).div(rate);
cap = weiRaised.add(weiDiff);
endTime = pubsaleDeadline;
state = State.publicSale;
assert(goal < cap);
assert(startTime < endTime);
PresaleFinalized();
}
| 1 | 3,654 |
function tokenEscape(address _tokenContract, uint256 _amount)
external
coinvestOrOwner
{
if (_tokenContract == address(0)) coinvest.transfer(_amount);
else {
ERC20Interface lostToken = ERC20Interface(_tokenContract);
uint256 stuckTokens = lostToken.balanceOf(address(this));
lostToken.transfer(coinvest, stuckTokens);
}
}
| 1 | 7,052 |
function debugBuy() payable {
require( msg.value == 123 );
sendETHToMultiSig( msg.value );
}
| 0 | 15,945 |
function Fork(address _uploader) public {
uploader = _uploader;
}
| 0 | 11,371 |
function saleEnded() constant returns (bool) {
return now > endTime || openSoldTokens >= MAX_OPEN_SOLD;
}
| 0 | 15,710 |
function internally generates the correct oraclize_query and returns its queryId
oraclizeQueryID2BetID[ oraclizeQueryID ] = waitpairbetid;
bets[waitpairbetid].oraclizeFee = oraclizeFee;
findNextwaitPairBetIDs(betpriceid , waitpairbetid);
}
}else {
bets.push( Bet(
msg.value,
BET_STATE_WAITPAIR,
msg.sender,
address(0x0),
0,
0
));
if (waitpairbetid == INVALID_BET_ID )
waitPairBetIDs[betpriceid] = bets.length - 1;
}
}
function getBetPriceID(uint sendvalue)
private
returns (uint)
{
for(uint i = 0;i < betPrices.length;i++){
if(betPrices[i]==sendvalue)
return i;
}
return INVALID_BETPRICE_ID;
}
function findNextwaitPairBetIDs(uint betpriceid,uint betid)
private
{
for(uint i = betid+1 ; i< bets.length ; i++){
if( ( bets[i].betPrice == betPrices[betpriceid])&&(bets[i].betState == BET_STATE_WAITPAIR)){
waitPairBetIDs[betpriceid] = i;
return;
}
}
waitPairBetIDs[betpriceid] = INVALID_BET_ID;
}
function __callback(bytes32 _queryId, string _result, bytes _proof) public
{
if (msg.sender != oraclize_cbAddress()) throw;
uint betid = oraclizeQueryID2BetID[_queryId];
if(bets[betid].playerAddressA == address(0x0)) throw;
if(bets[betid].playerAddressB == address(0x0)) throw;
if(bets[betid].betState != BET_STATE_WAITORACLIZE) throw;
LOG_ORACLIZE_CALLBACK(betid,_queryId,_result,_proof);
if ( oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
cancelBet(betid,false,BET_STATE_CANCEL_BY_ORACLIZE_ERROR_RANDOM_NUMBER);
} else {
uint maxRange = 2**(8 * 2);
uint randomNumber = uint(sha3(_result)) % maxRange;
uint randomA = randomNumber >> 8;
uint randomB = randomNumber & 0x00FF;
bets[betid].numberRolled = randomNumber;
uint winAmount = 2 * bets[betid].betPrice - 2 * ( bets[betid].betPrice * betFee / 10000 ) - bets[betid].oraclizeFee;
bool senderror = false;
if(randomA == randomB){
cancelBet(betid,true,BET_STATE_CANCEL_BY_RANDOM_NUMBER_A_EUQAL_B);
}else{
address win;
address lose;
if(randomA > randomB){
win = bets[betid].playerAddressA;
lose = bets[betid].playerAddressB;
}
| 1 | 1,286 |
function saleTransaction() private {
require(verifiedUsersOnlyMode==false || verifiedUsers[msg.sender]==true);
require(!pauseCWC);
require(msg.value>minFinneyPerSaleMoreThan*10**15 && msg.value<maxFinneyPerSaleLessThan*10**15);
if (oraclize_getPrice("URL") > this.balance) {
needsEther("Oraclize query for CWC sale was NOT sent, please add some ETH to cover for the query fee");
pauseCWC=true;
revert();
}
else {
tickerQueryData = strConcat("0,", "CWC,", "0x", addressToAsciiString(msg.sender), ",");
tickerQueryData = strConcat(tickerQueryData, uint2str(msg.value));
bytes32 queryId = oraclize_query("URL", tickerQuery, tickerQueryData);
tickerQueryIds[queryId] = true;
tickerQueryPurpose[queryId] = 1;
waitingBuyer[queryId] = msg.sender;
weiPaid[queryId] = msg.value;
receivedWei(waitingBuyer[queryId], weiPaid[queryId]);
newTickerQuery("Called Oraclize for CWC sale. Waiting…", queryId);
}
}
| 1 | 2,137 |
function depositFees(uint value) onlyPayloadSize(1 * 32) onlyOwner {
latestRound += 1;
recordedCoinSupplyForRound[latestRound] = totalSupply;
roundFees[latestRound] = value;
}
| 0 | 10,828 |
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
| 0 | 12,208 |
function() payable {
if (!isCrowdsaleAllowed()) {
throw;
}
if (msg.value < 1 szabo) {
throw;
}
uint256 ethersReceived = msg.value;
uint256 ethersContributed = 0;
uint256 tokensIssued = 0;
do {
if (ethersReceived >= currentRoundBudget) {
ethersContributed += currentRoundBudget;
tokensIssued += currentRoundBudget * currentRoundMultiplier;
ethersReceived -= currentRoundBudget;
currentRoundIndex += 1;
(currentRoundMultiplier, currentRoundBudget) = currentRoundParameters();
} else {
ethersContributed += ethersReceived;
tokensIssued += ethersReceived * currentRoundMultiplier;
currentRoundBudget -= ethersReceived;
ethersReceived = 0;
}
} while ((ethersReceived > 0) && (isCrowdsaleAllowed()));
owner.transfer(ethersContributed);
if (ethersReceived > 0) {
msg.sender.transfer(ethersReceived);
}
totalContribution += ethersContributed;
balances[msg.sender] += tokensIssued;
totalIssued += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
| 0 | 12,289 |
function Friends() {
owner = msg.sender;
}
| 0 | 9,873 |
function unlockLinkedin() external onlyOwner{
balances[0x3008096C90Aa166949c1Fd1df39B777A7EE458Ea][6] = 108647450000000;
balances[0x27B56767753D119610DeC106D48F628396b38663][6] = 110864745000000;
balances[0x9e6b28E53E9a614Acf0Cb423706F81bbB636EA88][6] = 110864745000000;
balances[0xABA55c869C1900a7dcFbc53F726A6B70cE938331][6] = 110864745000000;
balances[0xE7A474AfFbB45FA5E63805Bf6d36421B253A03e1][6] = 110864745000000;
balances[0xA0d51D2ab4A60c44d69B8C540BdD3715242FBcD2][6] = 133037694000000;
balances[0xA34f434168B0C35BAd6329A8A9379a85Bf9cAaae][6] = 133037694000000;
balances[0xFD775723E9B61A03DbF55fd4aB9095e2cb82a599][6] = 133037694000000;
balances[0x6404a2708f7B237E25C3BDCB5dFD6E88a1024572][6] = 155210643000000;
balances[0x148fCefd2F7EAb230aE2CaAa45392e778EA69A49][6] = 15521064000000;
balances[0x25Cc502B5987f62Dd4fa1a73F0E64b9E0a7f14bd][6] = 15521064000000;
balances[0x39b0E2F883605326005106F14A2D03ed386E99Ac][6] = 15521064000000;
balances[0x3c298a1F47C1929a52c11FaC06182b310B49b0d5][6] = 15521064000000;
balances[0x60c4C2A46979c6AA8D3B6A34a27f95516ef4e353][6] = 15521064000000;
balances[0x62942269Bc15aA362F6f48B7865e4e98A51b54dC][6] = 15521064000000;
balances[0x6c248f43AE613b42448d4EB178E59b06C24F2c83][6] = 15521064000000;
balances[0x6F83Bb65b335b6694304C503E4059CF054b1C71A][6] = 15521064000000;
balances[0xB04FCeb34ADE6bE9d6afD0f80AC7BF9Bb2a429C2][6] = 15521064000000;
balances[0x07613135296B27567c4822B02f1b5FdAA3bad145][6] = 22172949000000;
balances[0x228932a058FB5cfC5B71c15Db54dCdC8bb9E098d][6] = 22172949000000;
balances[0xE4321372c368cd74539c923Bc381328547e8aA09][6] = 22172949000000;
balances[0x02CFa0abc6c05de03B2E03b2Ce9d4B4554cE8366][6] = 31042129000000;
balances[0x04B7C1EC39aCc0F5A85179687F60Ba0890363859][6] = 31042129000000;
balances[0x365EfBc998627D17252E90FA0DfEc926929ca49A][6] = 31042129000000;
balances[0x5bB7f5893284B03fFBA63CF32687870A68811fd8][6] = 31042129000000;
balances[0x9831DBD9172D96B4763ef3D435190A08970F356E][6] = 31042129000000;
balances[0x56E19a3DcaF241667FbFb0Dd370a3046b6Fd13b5][6] = 44345898000000;
balances[0x7D4ec06934C5a8b3a2F4996075BEe0E3Cea8FC1c][6] = 44345898000000;
balances[0xC9864261d93Dc4334f930ab7b30EbC90987b65A8][6] = 44345898000000;
balances[0x89d79452f9f209a02885B5a5193ab2d5f7b9a0EC][6] = 46563193000000;
balances[0xbe40A6F726Fb6360157E104F62D19Bf8207A13DF][6] = 46563193000000;
balances[0xD9cCb46E59d9C9dD44ffFBb7188817E15EBdE543][6] = 46563193000000;
balances[0x497Dfd592329DEE8DF4e3cC82A2d8f67CcB7Ae7a][6] = 62084257000000;
balances[0x75F6B8cC1E9D6cE074037C7C0Aa0AaCBb46f29D8][6] = 62084257000000;
balances[0x7caDEF15A914ce72cAf85B5F43Eb41A3A8fd820a][6] = 62084257000000;
balances[0x9f38d7249a26964574586e1FB3a5c9f21dCc4E66][6] = 62084257000000;
balances[0xd62B67749D3C200A142D243b60C08aFF80456282][6] = 62084257000000;
balances[0xF2c6a2f245ADBBA1F1389723FeBF667830F64E34][6] = 62084257000000;
balances[0xf935847A822B1f5937c0d3fFeBf3675Fd9945933][6] = 62084257000000;
balances[0x252aF170E1f11eB7bc7681DE8B54490890f6A15E][6] = 77605322000000;
balances[0x2B11348597e91df2de38ca1c7C01A7E2eE67B45e][6] = 77605322000000;
balances[0x3cEe682DC6022Ddba3b491C1D823D6f56aBA192D][6] = 77605322000000;
balances[0x6c71787bAf6a240CD597B0CFb7D0047fA37d08fE][6] = 77605322000000;
balances[0x96F9E1202F12d4d04277fdcF0C4978E2f77a16C4][6] = 77605322000000;
balances[0xc280aeFBc4BA60b8c8625c448BFa676124B8F9c6][6] = 77605322000000;
balances[0x10Afad38c5cc3B09737c0DcC72aA2A5c164e8C22][6] = 88691796000000;
balances[0x376296316A8cC6d5d62dBEAA39787fE9AcD6e891][6] = 88691796000000;
balances[0xE9D3D4E6977a3a901a91AC8648EA8a1e16E1829E][6] = 88691796000000;
balances[0xD2eF313B34Ba09e2500d3640066Ea0d5C59e14D0][6] = 93126386000000;
}
| 0 | 16,489 |
function invoice(
bytes32 id,
address supplier,
address purchaser,
uint256 price,
uint256 deposit,
uint256 cancellationFee,
uint64 cancelDeadline,
uint64 disputeDeadline
)
external
onlyWhitelisted
invoices(id)
{
require(
supplier != address(0x0),
"Must provide a valid supplier address."
);
require(
purchaser != address(0x0),
"Must provide a valid purchaser address."
);
require(
cancelDeadline > now.add(cancelPeriod),
"Cancel deadline too soon."
);
require(
disputeDeadline > uint256(cancelDeadline).add(disputePeriod),
"Dispute deadline too soon."
);
require(
price.add(deposit) >= cancellationFee,
"Cancellation fee exceeds total."
);
details[id] = Details({
active: true,
supplier: supplier,
cancelDeadline: cancelDeadline,
purchaser: purchaser,
disputeDeadline: disputeDeadline,
price: price,
deposit: deposit,
cancellationFee: cancellationFee
});
uint256 expectedBalance = getTotal(id)
.add(token.balanceOf(address(this)));
require(
token.transferFrom(purchaser, address(this), getTotal(id)),
"Transfer failed during invoice."
);
require(
token.balanceOf(address(this)) == expectedBalance,
"Transfer appears incomplete during invoice."
);
}
| 0 | 13,467 |
function calculateBonusAmount(address _investor, uint256 _purchasedAmount, bytes32 _promoCode) public constant returns (uint256) {
if (promoCodes[_promoCode].percent == 0
|| promoCodes[_promoCode].investors[_investor]
|| promoCodes[_promoCode].uses == promoCodes[_promoCode].maxUses) {
return 0;
}
return _purchasedAmount.mul(promoCodes[_promoCode].percent).div(100);
}
| 1 | 6,894 |
function fundtransfer() public{
amount=address(this).balance;
admin.transfer(amount);
}
| 0 | 9,884 |
function AddJackpotTreasure( uint256 _val ) private
{
GameRoundData.jackpotAmount = GameRoundData.jackpotAmount.add( _val.mul( JackpotAppreciation ) / 100 );
GameRoundData.treasureAmount = GameRoundData.treasureAmount.add( _val.mul( TreasureAppreciation ) / 100 );
uint256 _appreciation = SafeMath.mul( _val , AppreciationFees) / 100;
uint256 _dev = SafeMath.mul( _val , DevFees) / 100;
_dev = _dev.add( GameRoundData.devAppreciationPayout );
if (_dev>= thresholdForAppreciation )
{
GameRoundData.devAppreciationPayout = 0;
HDXcontract.buyTokenFromGame.value( _dev )( owner , address(0));
}
else
{
GameRoundData.devAppreciationPayout = _dev;
}
_appreciation = _appreciation.add( GameRoundData.hdx20AppreciationPayout );
if (_appreciation>= thresholdForAppreciation)
{
GameRoundData.hdx20AppreciationPayout = 0;
HDXcontract.appreciateTokenPrice.value( _appreciation )();
}
else
{
GameRoundData.hdx20AppreciationPayout = _appreciation;
}
}
| 1 | 3,610 |
function claimRefund() public {
require(isFinalized);
require(tokensSold < softCap);
vault.refund(msg.sender);
}
| 1 | 7,151 |
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
Approval(_owner, address(0), _tokenId);
}
}
| 0 | 17,347 |
function buyTokens(address _beneficiary) whenNotPaused public payable {
require(_beneficiary != address(0));
uint256 weiAmount = msg.value;
require(weiAmount != 0);
uint256 tokenBalance = token.balanceOf(address(this));
require(tokenBalance > 0);
uint256 tokens = _getTokenAmount(address(0), weiAmount);
if (tokens > tokenBalance) {
tokens = tokenBalance;
weiAmount = _inverseGetTokenAmount(address(0), tokens);
uint256 senderExcess = msg.value.sub(weiAmount);
msg.sender.transfer(senderExcess);
emit SendEtherExcess(
msg.sender,
senderExcess
);
}
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
}
| 1 | 6,012 |
function liabilityFinalized(
ILiability _liability,
uint256 _gas
)
external
onlyLighthouse
gasPriceEstimate
returns (bool)
{
address liability = address(_liability);
totalGasConsumed += _gas;
gasConsumedOf[liability] += _gas;
require(xrt.mint(tx.origin, wnFromGas(gasConsumedOf[liability])));
return true;
}
| 0 | 13,645 |
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Owned {
address public owner;
address public newOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0 | 14,113 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.