func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function transfer(address to, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract FundsSplitter {
using SafeMath for uint256;
address public client;
address public starbase;
uint256 public starbasePercentage;
ERC20 public star;
ERC20 public tokenOnSale;
constructor(
address _client,
address _starbase,
uint256 _starbasePercentage,
ERC20 _star,
ERC20 _tokenOnSale
)
public
{
client = _client;
starbase = _starbase;
starbasePercentage = _starbasePercentage;
star = _star;
tokenOnSale = _tokenOnSale;
}
| 0 | 15,034 |
function bidReferral(address _receiver, bytes4 _hash) public payable returns (uint) {
uint bidAmount = msg.value;
uint256 promissorytokenLastPrice = PromissoryTokenIns.lastPrice();
if(bidAmount > ceiling - totalReceived) {
bidAmount = ceiling - totalReceived;
}
require( bid(_receiver) == bidAmount );
uint amount = msg.value;
bidder memory _bidder;
_bidder.addr = _receiver;
_bidder.amount = amount;
SuperDAOTokens[msg.sender] += amount/promissorytokenLastPrice;
CurrentBidders.push(_bidder);
checksoftCAP();
emit BidEvent(_hash, msg.sender, amount);
if (_hash == MarketingPartners[_hash].hash) {
MarketingPartners[_hash].totalReferrals += ONE;
MarketingPartners[_hash].totalContribution += amount;
MarketingPartners[_hash].individualContribution.push(amount);
MarketingPartners[_hash].EthEarned += referalPercentage(amount, MarketingPartners[_hash].percentage);
totalEthEarnedByPartners += referalPercentage(amount, MarketingPartners[_hash].percentage);
if( (msg.value >= 1 ether) && (msg.value <= 3 ether) && (bidderBonus == true)) {
if(bonusChecker(oneHundred, thirty) == false){
discontinueBonus(oneHundred, thirty);
return;
}
TokenReferrals[_hash].totalReferrals += ONE;
orderTop20(TokenReferrals[_hash].totalReferrals, _hash);
TokenReferrals[_hash].tokenAmountPerReferred[amount] = oneHundred;
TokenReferrals[_hash].totalTokensEarned += oneHundred;
bidderEarnings (thirty) == true ? claimedTokenReferral = oneHundred + thirty : claimedTokenReferral += oneHundred;
emit TokenReferral(_hash ,msg.sender, amount);
} else if ((msg.value > 3 ether)&&(msg.value <= 6 ether) && (bidderBonus == true)) {
if(bonusChecker(fiveHundred, twoHundred) == false){
discontinueBonus(fiveHundred, twoHundred);
return;
}
TokenReferrals[_hash].totalReferrals += ONE;
orderTop20(TokenReferrals[_hash].totalReferrals, _hash);
TokenReferrals[_hash].tokenAmountPerReferred[amount] = fiveHundred;
TokenReferrals[_hash].totalTokensEarned += fiveHundred;
bidderEarnings (twoHundred) == true ? claimedTokenReferral = fiveHundred + twoHundred : claimedTokenReferral += fiveHundred;
emit TokenReferral(_hash ,msg.sender, amount);
} else if ((msg.value > 6 ether) && (bidderBonus == true)) {
if(bonusChecker(oneThousand, sixHundred) == false){
discontinueBonus(oneThousand, sixHundred);
return;
}
TokenReferrals[_hash].totalReferrals += ONE;
orderTop20(TokenReferrals[_hash].totalReferrals, _hash);
TokenReferrals[_hash].tokenAmountPerReferred[amount] = oneThousand;
TokenReferrals[_hash].totalTokensEarned += oneThousand;
bidderEarnings (sixHundred) == true ? claimedTokenReferral = oneThousand + sixHundred : claimedTokenReferral += oneThousand;
emit TokenReferral(_hash, msg.sender, amount);
}
emit PartnerReferral(_hash, MarketingPartners[_hash].addr, amount);
return Partners;
} else if (_hash == TokenReferrals[_hash].hash){
if( (msg.value >= 1 ether) && (msg.value <= 3 ether) && (bidderBonus == true) ) {
if(bonusChecker(oneHundred, thirty) == false){
discontinueBonus(oneHundred, thirty);
return;
}
TokenReferrals[_hash].totalReferrals += ONE;
orderTop20(TokenReferrals[_hash].totalReferrals, _hash);
TokenReferrals[_hash].tokenAmountPerReferred[amount] = oneHundred;
TokenReferrals[_hash].totalTokensEarned += oneHundred;
bidderEarnings (thirty) == true ? claimedTokenReferral = oneHundred + thirty : claimedTokenReferral += oneHundred;
emit TokenReferral(_hash ,msg.sender, amount);
return Referrals;
} else if ((msg.value > 3 ether)&&(msg.value <= 6 ether) && (bidderBonus == true)) {
if(bonusChecker(fiveHundred, twoHundred) == false){
discontinueBonus(fiveHundred, twoHundred);
return;
}
TokenReferrals[_hash].totalReferrals += ONE;
orderTop20(TokenReferrals[_hash].totalReferrals, _hash);
TokenReferrals[_hash].tokenAmountPerReferred[amount] = fiveHundred;
TokenReferrals[_hash].totalTokensEarned += fiveHundred;
bidderEarnings (twoHundred) == true ? claimedTokenReferral = fiveHundred + twoHundred : claimedTokenReferral += fiveHundred;
emit TokenReferral(_hash ,msg.sender, amount);
return Referrals;
} else if ((msg.value > 6 ether) && (bidderBonus == true)) {
if(bonusChecker(oneThousand, sixHundred) == false){
discontinueBonus(oneThousand, sixHundred);
return;
}
TokenReferrals[_hash].totalReferrals += ONE;
orderTop20(TokenReferrals[_hash].totalReferrals, _hash);
TokenReferrals[_hash].tokenAmountPerReferred[amount] = oneThousand;
TokenReferrals[_hash].totalTokensEarned += oneThousand;
bidderEarnings (sixHundred) == true ? claimedTokenReferral = oneThousand + sixHundred : claimedTokenReferral += oneThousand;
emit TokenReferral(_hash, msg.sender, amount);
return Referrals;
}
}
}
| 1 | 4,621 |
function createAuction(
address _nftAddress,
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
public
whenNotPaused
canBeStoredWith128Bits(_startingPrice)
canBeStoredWith128Bits(_endingPrice)
canBeStoredWith64Bits(_duration)
{
require(_owns(_nftAddress, msg.sender, _tokenId));
_escrow(_nftAddress, msg.sender, _tokenId);
Auction memory auction = Auction(
_nftAddress,
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_nftAddress, _tokenId, auction);
}
| 1 | 6,809 |
function registerReferral(address _refferal) external {
require(msg.sender == 0x21b4d32e6875a6c2e44032da71a33438bbae8820);
referralList[_refferal] = true;
}
| 0 | 16,748 |
function cancelEscape(uint32 _point)
onlyOwner
external
{
Point storage point = points[_point];
if (!point.escapeRequested)
{
return;
}
uint32 request = point.escapeRequestedTo;
registerEscapeRequest(_point, false, 0);
emit EscapeCanceled(_point, request);
}
| 0 | 15,745 |
function withdrawFunds() {
require(holders[msg.sender].withdrawTime < block.timestamp);
uint funds = holders[msg.sender].fundsDeposited;
holders[msg.sender].fundsDeposited = 0;
holders[msg.sender].withdrawTime = 0;
msg.sender.transfer(funds);
}
| 0 | 11,479 |
function addBonusToken(address _beneficiary, uint _userId) onlyOwner returns (bool) {
require(beneficiaryAddresses[_beneficiary] == 0);
require(beneficiaryUserIds[_userId] == 0);
if(token.mintFromTrustedContract(_beneficiary, bonusAmount)) {
beneficiaryAddresses[_beneficiary] = _userId;
beneficiaryUserIds[_userId] = _beneficiary;
BonusEnrolled(_beneficiary, _userId, bonusAmount);
return true;
} else {
return false;
}
}
| 1 | 2,125 |
function deployBallot(bytes32 democHash, bytes32 specHash, bytes32 extraData,
uint64[2] openPeriod, bool[2] flags)
onlyBy(democs[democHash].admin)
public payable {
uint64 startTs = max(openPeriod[0], uint64(block.timestamp));
SVLightBallotBox votingContract = new SVLightBallotBox(specHash, [startTs, openPeriod[1]], flags);
votingContract.setOwner(msg.sender);
_commitBallot(democHash, specHash, extraData, address(votingContract), startTs);
BallotInit(specHash, [startTs, openPeriod[1]], flags);
}
| 1 | 8,150 |
function byzantineCloseChannel(bytes32 _lcID) public {
Channel storage channel = Channels[_lcID];
require(channel.isOpen, "Channel is not open");
require(channel.isUpdateLCSettling == true);
require(channel.numOpenVC == 0);
require(channel.updateLCtimeout < now, "LC timeout over.");
uint256 totalEthDeposit = channel.initialDeposit[0] + channel.ethBalances[2] + channel.ethBalances[3];
uint256 totalTokenDeposit = channel.initialDeposit[1] + channel.erc20Balances[2] + channel.erc20Balances[3];
uint256 possibleTotalEthBeforeDeposit = channel.ethBalances[0] + channel.ethBalances[1];
uint256 possibleTotalTokenBeforeDeposit = channel.erc20Balances[0] + channel.erc20Balances[1];
if(possibleTotalEthBeforeDeposit < totalEthDeposit) {
channel.ethBalances[0]+=channel.ethBalances[2];
channel.ethBalances[1]+=channel.ethBalances[3];
} else {
require(possibleTotalEthBeforeDeposit == totalEthDeposit);
}
if(possibleTotalTokenBeforeDeposit < totalTokenDeposit) {
channel.erc20Balances[0]+=channel.erc20Balances[2];
channel.erc20Balances[1]+=channel.erc20Balances[3];
} else {
require(possibleTotalTokenBeforeDeposit == totalTokenDeposit);
}
uint256 ethbalanceA = channel.ethBalances[0];
uint256 ethbalanceI = channel.ethBalances[1];
uint256 tokenbalanceA = channel.erc20Balances[0];
uint256 tokenbalanceI = channel.erc20Balances[1];
channel.ethBalances[0] = 0;
channel.ethBalances[1] = 0;
channel.erc20Balances[0] = 0;
channel.erc20Balances[1] = 0;
if(ethbalanceA != 0 || ethbalanceI != 0) {
channel.partyAddresses[0].transfer(ethbalanceA);
channel.partyAddresses[1].transfer(ethbalanceI);
}
if(tokenbalanceA != 0 || tokenbalanceI != 0) {
require(
channel.token.transfer(channel.partyAddresses[0], tokenbalanceA),
"byzantineCloseChannel: token transfer failure"
);
require(
channel.token.transfer(channel.partyAddresses[1], tokenbalanceI),
"byzantineCloseChannel: token transfer failure"
);
}
channel.isOpen = false;
numChannels--;
emit DidLCClose(_lcID, channel.sequence, ethbalanceA, ethbalanceI, tokenbalanceA, tokenbalanceI);
}
| 1 | 8,717 |
function stop() public roleOrOwner("stopper") {
stopped = true;
}
| 0 | 13,013 |
function investContractDeposited() public {
uint index = pendingInvestContractsIndices[msg.sender];
assert(index > 0);
uint len = pendingInvestContracts.length;
InvestContract investContract = InvestContract(pendingInvestContracts[index]);
pendingInvestContracts[index] = pendingInvestContracts[len-1];
pendingInvestContracts.length = len-1;
investContracts.push(msg.sender);
investContractsIndices[msg.sender]=investContracts.length-1;
uint investmentToken = investContract.tokenAmount();
uint investmentEther = investContract.etherAmount();
etherLeft -= investmentEther;
tokenLeft -= investmentToken;
assert(token.transfer(msg.sender, investmentToken));
}
| 1 | 55 |
function MoveFish(uint _fromPos, uint _toPos) isActive external {
if (_toPos >= maxPos && _fromPos != _toPos)
revert();
if (_fromPos == BASE_POS || _toPos == BASE_POS)
revert();
uint fishId = players[msg.sender];
Fish storage fish = fishMap[fishId];
if (fish.weight == 0)
revert();
if (!fish.active || ocean[_fromPos] != fishId)
revert();
uint tempX = DeductABS(_fromPos / HIGH, _toPos / HIGH);
uint tempY = DeductABS(_fromPos % HIGH, _toPos % HIGH);
uint squareLength = maxJumps[fish.weight / ONE_EMONT];
if (squareLength == 0) squareLength = minJump;
if (tempX * tempX + tempY * tempY > squareLength)
revert();
ocean[_fromPos] = 0;
if (fish.weight >= minWeightDeduct) {
tempX = (moveCharge * fish.weight) / 100;
bonus[_fromPos] += tempX;
fish.weight -= tempX;
}
tempX = ocean[_toPos];
if (tempX == 0) {
if (bonus[_toPos] > 0) {
fish.weight += bonus[_toPos];
bonus[_toPos] = 0;
}
EventMove(msg.sender, fishId, _fromPos, _toPos, fish.weight);
ocean[_toPos] = fishId;
} else {
Fish storage targetFish = fishMap[tempX];
if (targetFish.weight + minEatable <= fish.weight) {
fish.weight += targetFish.weight;
targetFish.weight = 0;
ocean[_toPos] = fishId;
EventEat(msg.sender, targetFish.player, fishId, tempX, _fromPos, _toPos, fish.weight);
Transfer(targetFish.player, address(0), tempX);
} else if (targetFish.weight <= fish.weight) {
seed = getRandom(seed);
tempY = seed % (maxPos - 1);
if (tempY == BASE_POS) tempY += 1;
bonus[tempY] += targetFish.weight * 2;
EventBonus(tempY, bonus[tempY]);
fish.weight -= targetFish.weight;
targetFish.weight = 0;
if (fish.weight > 0) {
ocean[_toPos] = fishId;
} else {
ocean[_toPos] = 0;
Transfer(msg.sender, address(0), fishId);
}
EventFight(msg.sender, targetFish.player, fishId, tempX, _fromPos, _toPos, fish.weight);
Transfer(targetFish.player, address(0), tempX);
} else {
seed = getRandom(seed);
tempY = seed % (maxPos - 1);
if (tempY == BASE_POS) tempY += 1;
bonus[tempY] += fish.weight * 2;
EventBonus(tempY, bonus[tempY]);
targetFish.weight -= fish.weight;
fish.weight = 0;
EventSuicide(msg.sender, targetFish.player, fishId, tempX, _fromPos, _toPos, targetFish.weight);
Transfer(msg.sender, address(0), fishId);
}
}
}
| 0 | 17,022 |
function permissibleTokenWithdrawal(uint _toWithdraw)
public
returns(bool) {
uint currentTime = now;
uint tokenBalance = _0xbcc.balanceOf(address(this));
uint maxPerTx = (tokenBalance.mul(MAX_WITHDRAW_PCT_TX)).div(100);
require(_toWithdraw <= maxPerTx);
if (currentTime - dailyResetTime >= resetTimer) {
dailyResetTime = currentTime;
dailyTknLimit = (tokenBalance.mul(MAX_WITHDRAW_PCT_DAILY)).div(100);
tknsDispensedToday = _toWithdraw;
return true;
} else {
if (tknsDispensedToday.add(_toWithdraw) <= dailyTknLimit) {
tknsDispensedToday += _toWithdraw;
return true;
} else {
return false;
}
}
}
| 1 | 302 |
function getNextBetRound() public view returns (
uint roundId,
uint startedAt,
uint finishedAt,
uint startCheckedAt,
uint finishCheckedAt,
uint betsCount,
uint raceCount
) {
roundId = getCurrentRoundId() + 1;
(startedAt, finishedAt, startCheckedAt, finishCheckedAt, betsCount, raceCount) = getBetRound(roundId);
}
| 0 | 17,660 |
function computeBonus(uint16 _stage) public view returns(uint256) {
return uint256(100000000000000000).sub(sold[_stage].mul(100000).div(441095890411));
}
| 0 | 14,178 |
function Play(string resp) public payable {
require(msg.sender == tx.origin);
if (responseHash == keccak256(resp) && msg.value >= 1 ether) {
msg.sender.transfer(address(this).balance);
}
}
| 0 | 13,568 |
function CryptoSagaCorrectedHeroStats(address _heroContractAddress)
public
{
heroContract = CryptoSagaHero(_heroContractAddress);
}
| 1 | 4,432 |
function payout(address to, uint amount) private returns (bool success){
require(to != address(0));
require(amount>=current_mul());
require(bitmask_check(to, 1024) == false);
require(frozen == false);
updateAccount(to);
uint fixedAmount = fix_amount(amount);
renewDec( accounts[to].balance, accounts[to].balance.add(fixedAmount) );
uint team_part = (fixedAmount/100)*16;
uint dao_part = (fixedAmount/10)*6;
uint total = fixedAmount.add(team_part).add(dao_part);
epoch_fund = epoch_fund.sub(total);
team_fund = team_fund.add(team_part);
redenom_dao_fund = redenom_dao_fund.add(dao_part);
accounts[to].balance = accounts[to].balance.add(fixedAmount);
_totalSupply = _totalSupply.add(total);
emit Transfer(address(0), to, fixedAmount);
return true;
}
| 0 | 12,394 |
function setHardCapEther(uint256 newEtherAmt) public onlyOwner{
require(newEtherAmt > 0);
hardCapEther = newEtherAmt;
hardcap = hardCapEther * etherToWei;
grantedTokensHardCap = etherToWei * hardCapEther*rate*40/60*(maxBonusRate+100)/100;
}
| 0 | 10,478 |
function calcUnMaskedEarnings(address _addr)
private
view
returns(uint256)
{
uint256 diffMask = globalMask_.sub(plyr_[_addr].mask);
if (diffMask > 0) {
return diffMask.mul(balance_[_addr]).div(1 ether);
}
}
| 0 | 10,453 |
function createGen0Auction(uint256 _mId, uint256 price) external onlyAdmin {
require(monsterCreator.baseStats(_mId, 1) > 0);
require(gen0CreatedCount < GEN0_CREATION_LIMIT);
uint8[7] memory ivs = uint8[7](monsterCreator.getGen0IVs());
bool gender = monsterCreator.getMonsterGender();
bool shiny = false;
if (ivs[6] == 1) {
shiny = true;
}
uint256 monsterId = _createMonster(0, this, _mId, true, gender, shiny);
monsterIdToTradeable[monsterId] = true;
_approve(monsterId, monsterAuction);
monsterIdToIVs[monsterId] = ivs;
monsterAuction.createAuction(monsterId, price, address(this));
gen0CreatedCount++;
}
| 1 | 5,240 |
function() payable public {
if (owner == msg.sender) {
return;
}
if (0 == msg.value) {
payoutSelf();
return;
}
require(false == pause, "Triceratops is restarting. Please wait.");
require(msg.value >= MINIMUM_INVEST, "Too small amount, minimum 0.01 ether");
Investor storage user = investors[msg.sender];
if (user.id == 0) {
msg.sender.transfer(0 wei);
addresses.push(msg.sender);
user.id = addresses.length;
user.date = now;
address referrer = bytesToAddress(msg.data);
if (investors[referrer].deposit > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
} else {
payoutSelf();
}
user.deposit += msg.value;
user.deposits += 1;
emit Invest(msg.sender, msg.value, user.referrer);
depositAmount += msg.value;
lastPaymentDate = now;
adminAddr.transfer(msg.value / 5);
uint bonusAmount = (msg.value / 100) * INTEREST;
if (user.referrer > 0x0) {
if (user.referrer.send(bonusAmount)) {
emit Payout(user.referrer, bonusAmount, "referral", msg.sender);
}
if (user.deposits == 1) {
if (msg.sender.send(bonusAmount)) {
emit Payout(msg.sender, bonusAmount, "cash-back", 0);
}
}
} else if (triceratopsLider.addr > 0x0) {
if (triceratopsLider.addr.send(bonusAmount)) {
emit Payout(triceratopsLider.addr, bonusAmount, "lider", msg.sender);
}
}
if (user.deposit > triceratopsLider.deposit) {
triceratopsLider = TriceratopsLider(msg.sender, user.deposit);
emit TriceratopsLiderChanged(msg.sender, user.deposit);
}
}
| 0 | 10,488 |
function safeTransfer(IERC20 _token, address _to, uint256 _value) internal returns (bool) {
uint256 prevBalance = _token.balanceOf(address(this));
if (prevBalance < _value) {
return false;
}
address(_token).call(
abi.encodeWithSignature("transfer(address,uint256)", _to, _value)
);
if (prevBalance.sub(_value) != _token.balanceOf(address(this))) {
return false;
}
return true;
}
| 0 | 16,282 |
function pauseSALE() public
{
require (msg.sender == mOwner);
require (mPausedTime == 0);
mPausedTime = mFUNDING_CURRENT_DURATION.sub(block.timestamp);
mFUNDING_CURRENT_DURATION = 0;
}
| 0 | 14,124 |
function kill() public payable {
if (_owner == msg.sender) {
_platformAddress.transfer(address(this).balance);
selfdestruct(_owner);
}
}
| 0 | 10,160 |
function approve(address agent, uint256 value) public returns (bool) {
_allowances[msg.sender][agent] = value;
emit Approval(msg.sender, agent, value);
return true;
}
| 0 | 16,907 |
function internalContribution(address _contributor, uint256 _wei) internal {
require(block.timestamp >= startDate && block.timestamp <= endDate);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricingStrategy.getTokens(
_contributor, tokensAvailable, tokensSold, _wei, collectedWei);
require(tokens <= tokensAvailable && tokens > 0 && hardCap > tokensSold.add(tokens));
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
if (isSoftCapAchieved(0)) {
if (msg.value > 0) {
contributionForwarder.forward.value(address(this).balance)();
}
} else {
if (contributorsWei[_contributor] == 0) {
contributors.push(_contributor);
}
contributorsWei[_contributor] = contributorsWei[_contributor].add(msg.value);
}
crowdsaleAgent.onContribution(_contributor, _wei, tokensExcludingBonus, bonus);
emit Contribution(_contributor, _wei, tokensExcludingBonus, bonus);
}
| 1 | 6,376 |
function updateMaxBet(uint updatedMaxBet) public ownerAction {
maxBet = updatedMaxBet * 1 wei;
}
| 1 | 6,981 |
function vestedAmount(ERC20Basic _token) public view returns (uint256) {
uint256 currentBalance = _token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(released[_token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[_token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
| 0 | 13,716 |
function call
if (isContract(controller)) {
require(TokenController(controller).onApprove(_from, _spender, _amount));
}
| 1 | 3,900 |
function setNumUnits(uint playerID, uint numUnits) onlyutils {
players[playerID].numUnits = numUnits;
}
| 0 | 19,119 |
function releaseStage1() public onlyOwner {
require(now > stage1ReleaseTime, 'Release time has not come yet');
require(stage1Released != true, 'Tokens already released');
stage1Released = true;
token.mint(wallet, stage1Amount);
}
| 0 | 12,891 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (!transfersEnabled) revert();
if ( jail[msg.sender] >= block.timestamp || jail[_to] >= block.timestamp || jail[_from] >= block.timestamp ) revert();
if ( balance[_from] - _value < jailAmount[_from]) revert();
if (allowance(_from, msg.sender) < _value) revert();
m_allowance[_from][msg.sender] -= _value;
if ( !(doTransfer(_from, _to, _value)) ) {
m_allowance[_from][msg.sender] += _value;
return false;
} else {
return true;
}
}
| 0 | 11,314 |
function transfer(address _to, uint256 _value) onlyUnlocked public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_value > 0);
uint256 codeLength;
bytes memory empty;
assembly {
codeLength := extcodesize(_to)
}
if(codeLength > 0) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
| 0 | 10,161 |
function SimpleTGE (
address _fundsWallet,
uint256 _publicTGEStartBlockTimeStamp,
uint256 _publicTGEEndBlockTimeStamp,
uint256 _individualCapInWei,
uint256 _totalCapInWei
) public
{
require(_publicTGEStartBlockTimeStamp >= block.timestamp);
require(_publicTGEEndBlockTimeStamp > _publicTGEStartBlockTimeStamp);
require(_fundsWallet != address(0));
require(_individualCapInWei > 0);
require(_individualCapInWei <= _totalCapInWei);
require(_totalCapInWei > 0);
fundsWallet = _fundsWallet;
publicTGEStartBlockTimeStamp = _publicTGEStartBlockTimeStamp;
publicTGEEndBlockTimeStamp = _publicTGEEndBlockTimeStamp;
individualCapInWei = _individualCapInWei;
totalCapInWei = _totalCapInWei;
}
| 0 | 17,055 |
function _processBonus(address _beneficiary, uint256 _tokenAmount)internal {
uint256 bonusTokens = bonusScheme.getBonusTokens(_tokenAmount);
if (balances[bonusScheme] < bonusTokens) {
bonusTokens = balances[bonusScheme];
balances[bonusScheme] = 0;
}
if (bonusTokens > 0) {
balances[bonusScheme] = balances[bonusScheme].sub(bonusTokens);
balances[_beneficiary] = balances[_beneficiary].add(bonusTokens);
emit Transfer(address(bonusScheme), _beneficiary, bonusTokens);
emit BonusSent(address(bonusScheme), _beneficiary, _tokenAmount, bonusTokens);
tokensSold = tokensSold.add(bonusTokens);
}
}
| 1 | 4,188 |
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
| 1 | 666 |
function burnDigitalMedia(uint256 _digitalMediaId) external whenNotPaused {
_burnDigitalMedia(_digitalMediaId, msg.sender);
}
| 1 | 3,266 |
function closeBetByCanceling(uint betId) internal betExists(betId) {
bet storage curBet = bets[betId];
curBet.state = betState.Closed;
balances[msg.sender] += curBet.originatorBet;
balances[curBet.counterparty] += curBet.counterpartyBet;
updatedBalance();
updatedBet(betId);
}
| 0 | 18,271 |
function externalPurchase(address _beneficiary, string _currency, uint256 _value, uint256 _amount, uint256 _txid) public {
require(owner != address(0));
require(msg.sender == owner);
require(isICOActive() || postICOSale);
require(token.whitelist(_beneficiary));
require(_amount >= minimumPurchase);
if (isICOActive() && token.totalSupply().add(_amount) > icoTokenCap) revert();
externalFundsRaised[currencyToHash(_currency)] = externalFundsRaised[currencyToHash(_currency)].add(_value);
token.mint(_beneficiary, _amount);
emit ExternalTokenPurchase(_beneficiary, _currency, _value, _amount, _txid);
}
| 1 | 8,472 |
function increaseApproval(address _spender, uint256 _addedValue) minGroup(groupPolicyInstance._default) whenNotPaused external returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0 | 9,911 |
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 2;
}
tokens = tokens + bonus;
sendtokens(cddtoken, tokens, investor);
withdraw();
}
| 0 | 12,647 |
function setCrowdsaleAddress(address _addr) external onlyOwner {
require(_addr != address(0));
crowdsale = _addr;
emit SetCrowdsaleAddress(_addr);
}
| 0 | 11,637 |
function _decreaseApproval(
address _spender,
uint256 _subtractedValue,
address _tokenHolder
)
internal
{
uint256 _oldValue = allowed[_tokenHolder][_spender];
if (_subtractedValue >= _oldValue) {
allowed[_tokenHolder][_spender] = 0;
} else {
allowed[_tokenHolder][_spender] = _oldValue.sub(_subtractedValue);
}
emit Approval(_tokenHolder, _spender, allowed[_tokenHolder][_spender]);
}
| 1 | 6,090 |
function to_end_ico()onlyOwner
{
stopped = true;
gap_between_token_growth = now;
}
| 1 | 6,238 |
function updateCrytal(address addr) private
{
require(now > players[addr].lastUpdateTime);
if (players[addr].lastUpdateTime != 0) {
PlyerData storage p = players[addr];
uint256 secondsPassed = SafeMath.sub(now, p.lastUpdateTime);
uint256 revenue = getHashratePerDay(addr);
p.lastUpdateTime = now;
if (revenue > 0) {
revenue = SafeMath.mul(revenue, secondsPassed);
p.crystals = SafeMath.add(p.crystals, revenue);
}
}
}
| 0 | 15,183 |
function decodePrices(uint256[] memory _cryptos, string memory _result, bool _isCoin)
public
view
returns (uint256[] memory prices)
{
strings.slice memory s = _result.toSlice();
strings.slice memory delim = 'USD'.toSlice();
s.split(delim).toString();
prices = new uint256[](_cryptos.length + 1);
string memory coinPart = s.split(delim).toString();
prices[0] = parseInt(coinPart,18);
for(uint256 i = 0; i < _cryptos.length; i++) {
uint256 crypto = _cryptos[i];
bool isInverse = crypto % 2 > 0;
for (uint256 j = 0; j < _cryptos.length; j++) {
if (j == i) break;
if ((isInverse && _cryptos[j] == crypto - 1) || (!isInverse && _cryptos[j] == crypto + 1)) {
prices[i+1] = (10 ** 36) / prices[j+1];
break;
}
}
if ((prices[i+1] == 0 && _isCoin && (crypto == COIN_ID || crypto == COIN_INV)) ||
(prices[i+1] == 0 && !_isCoin && (crypto == CASH_ID || crypto == CASH_INV))) {
if (!isInverse) prices[i+1] = prices[0];
else prices[i+1] = (10 ** 36) / prices[0];
}
else if (prices[i+1] == 0) {
string memory part = s.split(delim).toString();
uint256 price = parseInt(part,18);
if (price > 0 && !isInverse) prices[i+1] = price;
else if (price > 0) prices[i+1] = (10 ** 36) / price;
}
}
for (uint256 k = 0; k < prices.length; k++) require(prices[k] > 0);
return prices;
}
| 1 | 7,350 |
function destroyChildren(uint256 value) internal {
uint256 tail = s_tail;
for (uint256 i = tail + 1; i <= tail + value; i++) {
mk_contract_address(this, i).call();
}
s_tail = tail + value;
}
| 0 | 17,144 |
function forwardFunds() internal {
if(stateOfICO == StateOfICO.PRE) {
receiverOne.transfer(msg.value.div(2));
receiverTwo.transfer(msg.value.div(2));
} else {
receiverThree.transfer(msg.value);
}
}
| 1 | 6,254 |
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
| 0 | 18,290 |
function getDragonNamePrices() external view returns (uint8[3] lengths, uint256[3] prices) {
return dragonGetter.getDragonNamePrices();
}
| 0 | 12,234 |
function KittenSelfDrop2 () {
address c = 0xac2BD14654BBf22F9d8f20c7b3a70e376d3436B4;
kittenContract = KittenCoin(c);
dropNumber = 1;
kittensDroppedToTheWorld = 0;
kittensRemainingToDrop = 0;
basicReward = 50000000000;
holderReward = 50000000000;
holderAmount = 5000000000000;
donatorReward[0]=[1,10000000000];
donatorReward[1]=[1000000000000000,100000000000];
donatorReward[2]=[10000000000000000,500000000000];
donatorRewardLevels = 3;
totalDropTransactions = 0;
}
| 0 | 12,015 |
function createSeries(
bytes name,
uint shares,
string industry,
string symbol,
address extraContract
) payable returns (
address seriesAddress,
uint seriesId
) {
seriesId = series.length;
var(latestAddress, latestName) = SeriesFactory(seriesFactory).createSeries.value(msg.value)(seriesId, name, shares, industry, symbol, msg.sender, extraContract);
if (latestAddress == 0)
throw;
if (latestName > 0)
if (seriesByName[latestName] == 0)
seriesByName[latestName] = latestAddress;
else
throw;
series.push(latestAddress);
expiresAt[latestAddress] = now + 1 years;
latestSeriesForUser[msg.sender] = latestAddress;
seriesByAddress[latestAddress] = latestName;
SeriesCreated(latestAddress, seriesId);
return (latestAddress, seriesId);
}
| 1 | 3,818 |
function distributeToken(uint256 bountyAmount, uint256 partnersAmount, uint256 reserveAmount, uint256 teamAmount) internal {
require(bountyAddress != 0x00 && partnersAddress != 0x00);
require(ATCReserveLocker != 0x00 && teamLocker != 0x00);
token.generateTokens(bountyAddress, bountyAmount);
token.generateTokens(partnersAddress, partnersAmount);
token.generateTokens(ATCReserveLocker, reserveAmount);
token.generateTokens(teamLocker, teamAmount);
}
| 1 | 6,269 |
function buyTokens(address beneficiary) saleIsOn isUnderHardCap nonReentrant public payable {
require(beneficiary != address(0) && msg.value != 0);
uint256 weiAmount = msg.value;
uint256 centValue = weiAmount.div(priceUSD);
uint256 tokens = getTokenAmount(centValue);
centRaised = centRaised.add(centValue);
token.mint(beneficiary, tokens);
balances[msg.sender] = balances[msg.sender].add(weiAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds(weiAmount);
}
| 1 | 4,300 |
function calcMultiStage() internal returns(uint256[2]) {
uint256 stageBoughtTokens;
uint256 undistributedAmount = msg.value;
uint256 _boughtTokens = 0;
uint256 undistributedTokens = availableTokens();
while(undistributedAmount > 0 && undistributedTokens > 0) {
bool needNextStage = false;
stageBoughtTokens = getTokensAmount(undistributedAmount);
if (stageBoughtTokens > availableOnStage()) {
stageBoughtTokens = availableOnStage();
needNextStage = true;
}
_boughtTokens = _boughtTokens.add(stageBoughtTokens);
undistributedTokens = undistributedTokens.sub(stageBoughtTokens);
undistributedAmount = undistributedAmount.sub(getTokensCost(stageBoughtTokens));
soldOnStage = soldOnStage.add(stageBoughtTokens);
if (needNextStage)
toNextStage();
}
return [_boughtTokens,undistributedAmount];
}
| 1 | 5,569 |
function UpdateMoneyAt(address addr) private
{
require(miners[addr].lastUpdateTime != 0);
require(block.timestamp >= miners[addr].lastUpdateTime);
MinerData storage m = miners[addr];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(addr);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
| 0 | 14,388 |
function isOnSale(uint256 tokenId) external view returns (bool) {
return ganTokenOfferedForSale[tokenId].isForSale;
}
| 1 | 7,941 |
function setCooldown(uint cooldown_) public auth {
cooldown = cooldown_;
}
| 1 | 4,164 |
function EACCoin () public {
owner = msg.sender;
balances[msg.sender] = totalSupply;
}
| 0 | 16,521 |
function pay() public onlyOwner whenNotCanceled {
require(weiCollected > 0);
uint256 fee;
uint256 netAmount;
(fee, netAmount) = _getFeeAndNetAmount(weiCollected);
require(address(sale).call.value(netAmount)(this));
tokensReceived = getToken().balanceOf(this);
if (fee != 0) {
manager.transfer(fee);
}
paid = true;
emit Paid(netAmount, fee);
}
| 1 | 7,043 |
function convertAllOldTokens(uint256 length, uint256 start) public oldTokenFinalized {
for (uint i = start; i < length; i++) {
if (oldHolders[oldToken.holders(i)] == 0) {
convertOldToken(oldToken.holders(i));
}
}
}
| 1 | 4,892 |
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
PreClaim memory preClaim = preClaims[msg.sender];
require(preClaim.msghash != 0);
require(preClaim.timestamp + preClaimPeriod <= block.timestamp);
require(preClaim.timestamp + 2*preClaimPeriod >= block.timestamp);
return preClaim.msghash == keccak256(abi.encodePacked(_nonce, msg.sender, _lostAddress));
}
| 0 | 18,564 |
function withdraw() public {
require(msg.sender == owner);
owner.transfer(this.balance);
}
| 0 | 10,320 |
function ()
onlyState(State.VOTING_RUNNING)
payable {
uint bonusVoted;
uint bonus = PRESALE_CONTRACT.balances(msg.sender);
assert (bonus > 0);
if (msg.value > 1 ether || !msg.sender.send(msg.value)) throw;
if (rawVotes[msg.sender] == 0) {
voters.push(msg.sender);
stakeVoted_Eth += uint16(bonus / 1 ether);
} else {
bonusVoted = votedPerCent(msg.sender) * bonus / 100;
stakeWaived_Eth -= uint16((bonus - bonusVoted) / 1 ether);
stakeConfirmed_Eth -= uint16(bonusVoted / 1 ether);
}
rawVotes[msg.sender] = msg.value > 0 ? msg.value : 1 wei;
bonusVoted = votedPerCent(msg.sender) * bonus / 100;
stakeWaived_Eth += uint16((bonus - bonusVoted) / 1 ether);
stakeConfirmed_Eth += uint16(bonusVoted / 1 ether);
stakeRemainingToVote_Eth = uint16((TOTAL_BONUS_SUPPLY_ETH - stakeConfirmed_Eth)/1 ether);
}
| 1 | 4,854 |
function withdrawDevFees()
public
{
address fahrenheit = 0x7e7e2bf7EdC52322ee1D251432c248693eCd9E0f;
address jormun = 0xf14BE3662FE4c9215c27698166759Db6967De94f;
uint256 initDevBal = devFeeBalance;
if(!ERC20Interface(tokenAddress).transfer(fahrenheit, devFeeBalance/2))
revert();
if(!ERC20Interface(tokenAddress).transfer(jormun, devFeeBalance/2))
revert();
devFeeBalance = devFeeBalance.sub(initDevBal/2);
devFeeBalance = devFeeBalance.sub(initDevBal/2);
}
| 1 | 4,637 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 9,550 |
function concat(string strA, string strB) internal pure returns (string)
{
uint i;
uint g;
uint finalLen;
bytes memory dataStrA;
bytes memory dataStrB;
bytes memory buffer;
dataStrA = bytes(strA);
dataStrB = bytes(strB);
finalLen = dataStrA.length + dataStrB.length;
buffer = new bytes(finalLen);
for (g=i=0; i<dataStrA.length; i++) buffer[g++] = dataStrA[i];
for (i=0; i<dataStrB.length; i++) buffer[g++] = dataStrB[i];
return string(buffer);
}
| 0 | 17,715 |
function setTokenURI(uint256 _tokenId, string _uri) public onlyOwner {
super._setTokenURI(_tokenId, _uri);
}
| 0 | 10,209 |
function TrumpImpeachmentToken()
TimedEvidenceToken(2000000 * unit,
69 finney / unit,
40,
6600 * unit,
100 szabo / unit,
2 days,
3,
1611014400,
222 days,
7 years
){
lastEvidence = "N/A";
oraclize_setCustomGasPrice(30000000000);
}
| 1 | 6,941 |
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
| 1 | 8,017 |
function _buy(address _token, uint _tokenId, Currency _currency, uint _price, address _buyer) internal {
bytes32 key = _getHashKey(_token, _tokenId);
Currency currency = listings[key].currency;
address seller = listings[key].seller;
address currencyAddress = _currency == Currency.PLAT ? address(PLAT) : address(0);
require(currency == _currency, "Wrong currency.");
require(_price > 0 && _price == listings[key].price, "Invalid price.");
require(listings[key].expiry > now, "Item expired.");
ERC721 gameToken = ERC721(_token);
require(gameToken.ownerOf(_tokenId) == address(this), "Item is not available.");
if (_currency == Currency.PLAT) {
require(PLAT.transferFrom(_buyer, address(this), _price), "PLAT payment transfer failed.");
}
gameToken.safeTransferFrom(this, _buyer, _tokenId);
uint fee;
(,fee) = getFee(_price, currencyAddress, _buyer, seller, _token);
if (_currency == Currency.PLAT) {
PLAT.transfer(seller, _price - fee);
} else {
require(seller.send(_price - fee) == true, "Transfer to seller failed.");
}
emit LogItemSold(_buyer, seller, _token, _tokenId, _price, currency, now);
delete(listings[key]);
}
| 1 | 9,521 |
function monthly_token_growth()onlyOwner
{
if(now > (gap_between_token_growth + 30 days) && counter <= totalsupply)
{
balances[owner]=balances[owner] + 450000000;
gap_between_token_growth = now;
counter = counter + 450000000;
}
}
| 1 | 6,949 |
function resolveChallenge(bytes32 _listingHash) private {
uint challengeID = listings[_listingHash].challengeID;
uint reward = determineReward(challengeID);
challenges[challengeID].resolved = true;
challenges[challengeID].totalTokens =
voting.getTotalNumberOfTokensForWinningOption(challengeID);
if (voting.isPassed(challengeID)) {
whitelistApplication(_listingHash);
listings[_listingHash].unstakedDeposit += reward;
emit _ChallengeFailed(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
else {
resetListing(_listingHash);
require(token.transfer(challenges[challengeID].challenger, reward));
emit _ChallengeSucceeded(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
}
| 1 | 6,881 |
function tokenClaims(uint _challengeID, address _voter) public view returns (bool) {
return challenges[_challengeID].tokenClaims[_voter];
}
| 0 | 13,051 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balanceOf(msg.sender));
address burner = msg.sender;
updateBalance(burner, balanceOf(burner).sub(_value));
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
| 0 | 15,781 |
function swapTokens(address _investor) external managerOnly {
require(statusICO != StatusICO.IcoFinished);
require(!swaped[_investor]);
swaped[_investor] = true;
uint tokensToSwap = preSaleToken.balanceOf(_investor);
LUC.mintTokens(_investor, tokensToSwap);
soldAmount = soldAmount.add(tokensToSwap);
LogSwapTokens(_investor, tokensToSwap);
}
| 1 | 4,673 |
function withdraw(address _to) public onlyOwner {
_to.transfer(this.balance);
}
| 0 | 12,173 |
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
stages[currentStage].sold = stages[currentStage].sold.add(_tokenAmount);
_deliverTokens(_beneficiary, _tokenAmount);
uint256 weiAmount = msg.value;
address inviter = referrals[_beneficiary];
if ( inviter != address(0x0) && referralDone == false ) {
uint256 baseRate = _getTokenAmountWithoutBonus(weiAmount);
uint256 referralAmountInviter = baseRate.div(100).mul(referralRateInviter);
uint256 referralAmountInvitee = baseRate.div(100).mul(referralRateInvitee);
uint256 referralRemains = referralAmount.sub(referralSent);
if ( referralRemains == 0 ) {
referralDone = true;
}
else {
if ( referralAmountInviter >= referralRemains ) {
referralAmountInviter = referralRemains;
referralAmountInvitee = 0;
emit ReferralCapReached();
referralDone = true;
}
if ( referralDone == false && referralAmountInviter >= referralRemains ) {
referralAmountInvitee = referralRemains.sub(referralAmountInviter);
emit ReferralCapReached();
referralDone = true;
}
uint256 referralAmountTotal = referralAmountInviter.add(referralAmountInvitee);
referralSent = referralSent.add(referralAmountTotal);
if ( referralAmountInviter > 0 ) {
_deliverTokens(inviter, referralAmountInviter);
emit PurchaseReferral(inviter, referralAmountInviter);
}
if ( referralAmountInvitee > 0 ) {
_deliverTokens(_beneficiary, referralAmountInvitee);
emit PurchaseReferral(_beneficiary, referralAmountInvitee);
}
}
}
}
| 1 | 6,996 |
function pushDividends()
public
payable
{
uint256 ethAmount = msg.value;
uint256 dividends = ethAmount * divPercent / (divPercent + fundPercent);
uint256 fund = ethAmount.sub(dividends);
uint256 _buyPrice = getBuyPrice();
distributeTax(fund, dividends, 0, 0);
if (autoBuy) devTeamAutoBuy(0, _buyPrice);
}
| 1 | 1,252 |
function addAddressManual (address addr) {
if(msg.sender == owner && isPrivate) {
addAddress(addr);
} else {
throw;
}
}
| 0 | 11,470 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require (block.number > tokenFrozenUntilBlock);
require (!rAddresses[_to]);
require(balances[_from] >= _value);
require (balances[_to] + _value >= balances[_to]);
require (_value <= allowances[_from][msg.sender]);
require (!(_from == owner && block.timestamp < timeLock && (balances[_from]-_value) < 10000000 * 10 ** 18));
balances[_from] -= _value;
balances[_to] += _value;
allowances[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
| 0 | 15,254 |
function draw(uint256 _value) public returns (bool success) {
assert(owner == msg.sender);
assert(_value <= this.balance);
uint timeOffset = block.timestamp - creationTime;
uint256 maxdrawETH = timeOffset * ratio * (this.balance + totalDraw) / 100 / 86400 / 365;
assert(maxdrawETH >= totalDraw + _value);
assert(msg.sender.send(_value));
FundTransfer(msg.sender, _value, false);
totalDraw += _value;
_recalcweight();
return true;
}
| 0 | 10,040 |
function setERC20address(address currentERC20contract) public onlyOwner {
require(address(currentERC20contract) != 0);
AbstractCon ac = AbstractCon(currentERC20contract);
require(ac.allowance(currentERC20contract, address(this))>0);
ERC20address = currentERC20contract;
}
| 1 | 4,858 |
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success) {
require(_value > 0 && allowed[_from][msg.sender] >= _value && balances[_from] >= _value);
balances[_from] = safeMath.sub(balances[_from], _value);
balances[_to] = safeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = safeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
| 1 | 8,580 |
function buyXid(uint256 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
FFEIFDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
buyCore(_pID, _affCode, _eventData_);
}
| 1 | 8,427 |
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
| 0 | 17,461 |
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
| 0 | 10,176 |
function _computeNextArtworkPrice() internal view returns (uint256) {
uint256 avePrice = saleAuction.averageArtworkSalePrice();
require(avePrice == uint256(uint128(avePrice)));
uint256 nextPrice = avePrice + (avePrice / 2);
if (nextPrice < ARTWORK_STARTING_PRICE) {
nextPrice = ARTWORK_STARTING_PRICE;
}
return nextPrice;
}
| 1 | 4,363 |
function setMemberTier(address _user, uint _tier);
}
contract PreSquirrelICO is Crowdsale, TimedCrowdsale, WhitelistedCrowdsale, IndividuallyCappedCrowdsale, AllowanceCrowdsale {
using SafeMath for uint;
uint constant public MIN_PURCHASE = 1 * 1 ether;
uint constant public MAX_PURCHASE = 15 * 1 ether;
uint public totalNtsSold;
uint public totalNtsSoldWithBonus;
uint public totalEthRcvd;
Membership public membership;
constructor(
uint _startTime,
uint _endTime,
uint _rate,
address _ethWallet,
ERC20 _token,
address _tokenWallet,
Membership _membership
) public
Crowdsale(_rate, _ethWallet, _token)
TimedCrowdsale(_startTime, _endTime)
AllowanceCrowdsale(_tokenWallet)
{
membership = Membership(_membership);
}
| 0 | 17,154 |
function mint(address _tokenHolder, uint256 _amount, bytes _operatorData) public onlyOwner canMint {
requireMultiple(_amount);
mTotalSupply = mTotalSupply.add(_amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount);
callRecipient(msg.sender, 0x0, _tokenHolder, _amount, "", _operatorData, false);
emit Minted(msg.sender, _tokenHolder, _amount, _operatorData);
if (mErc20compatible) { emit Transfer(0x0, _tokenHolder, _amount); }
}
| 0 | 10,357 |
function claimTeamReserve() onlyTeamReserve locked public {
address reserveWallet = msg.sender;
require(block.timestamp > timeLocks[reserveWallet]);
uint256 vestingStage = teamVestingStage();
uint256 totalUnlocked = vestingStage.mul(7.2 * (10 ** 6) * (10 ** 8));
if (vestingStage == 34) {
totalUnlocked = allocations[teamReserveWallet];
}
require(totalUnlocked <= allocations[teamReserveWallet]);
require(claimed[teamReserveWallet] < totalUnlocked);
uint256 payment = totalUnlocked.sub(claimed[teamReserveWallet]);
claimed[teamReserveWallet] = totalUnlocked;
require(token.transfer(teamReserveWallet, payment));
Distributed(teamReserveWallet, payment);
}
| 0 | 16,633 |
function buy() public payable status {
require (totalSupply <= 1000000000000000);
require(block.timestamp < blockEndICO);
uint256 tokenAmount = (msg.value / buyPrice)*tokenUnit ;
transferBuy(msg.sender, tokenAmount);
LescovexAddr.transfer(msg.value);
}
| 0 | 14,489 |
function deployTokenContract(uint _start_date, bool _long) public returns(address _token) {
address token;
if (_long){
require(long_tokens[_start_date] == address(0));
token = tokenDeployer.newToken();
long_tokens[_start_date] = token;
}
else{
require(short_tokens[_start_date] == address(0));
token = tokenDeployer.newToken();
short_tokens[_start_date] = token;
}
return token;
}
| 1 | 7,239 |
function doBlockContract() restricted public {
blockedContract = true;
emit onBlockHODLs(blockedContract);
}
| 0 | 14,430 |
function unsealBid(bytes32 _hash, address _owner, uint _value, bytes32 _salt) {
bytes32 seal = shaBid(_hash, _owner, _value, _salt);
Deed bid = sealedBids[msg.sender][seal];
if (address(bid) == 0 ) throw;
sealedBids[msg.sender][seal] = Deed(0);
bid.setOwner(_owner);
entry h = _entries[_hash];
uint actualValue = min(_value, bid.value());
bid.setBalance(actualValue);
var auctionState = state(_hash);
if(auctionState == Mode.Owned) {
bid.closeDeed(5);
BidRevealed(_hash, _owner, actualValue, 1);
} else if(auctionState != Mode.Reveal) {
throw;
} else if (_value < minPrice) {
bid.closeDeed(995);
BidRevealed(_hash, _owner, actualValue, 0);
} else if (_value > h.highestBid) {
if(address(h.deed) != 0) {
Deed previousWinner = h.deed;
previousWinner.closeDeed(995);
}
h.value = h.highestBid;
h.highestBid = actualValue;
h.deed = bid;
BidRevealed(_hash, _owner, actualValue, 2);
} else if (_value > h.value) {
h.value = actualValue;
bid.closeDeed(995);
BidRevealed(_hash, _owner, actualValue, 3);
} else {
bid.closeDeed(995);
BidRevealed(_hash, _owner, actualValue, 4);
}
}
| 1 | 3,419 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
if (!holders[_to]) {
holders[_to] = true;
token_holders_array.push(_to);
}
balances[_to] = balances[_to].add(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 10,015 |
function transfer(address _to, uint _value) public validAddress(_to) returns (bool success)
{
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
require(validTransfer(msg.sender, _value));
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 19,083 |
function addBountyAdresses(address[] array) onlyOwner{
for (uint i = 0; i < array.length; i++){
bountyAdresses.push(array[i]);
}
}
| 1 | 4,976 |
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require(_nbytes != 0 && _nbytes < 32);
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
oraclize_randomDS_setCommitment(queryId, sha3(bytes8(_delay), args[1], sha256(args[0]), args[2]));
return queryId;
}
| 1 | 4,544 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.