func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Token {
string public name;
string public symbol;
uint8 public decimals;
string public version = 'v1';
uint256 public totalSupply;
uint public price;
bool locked;
address rootAddress;
address Owner;
uint multiplier;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => bool) freezed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier onlyOwner() {
if ( msg.sender != rootAddress && msg.sender != Owner ) revert();
_;
}
| 0 | 16,743 |
function invest() notOnPause public payable {
require(msg.value >= 0.01 ether);
admin.transfer(msg.value / 25);
if (x.r(msg.sender) != 0x0) {
refSystem();
} else if (msg.data.length == 20) {
uint bonus = addReferrer();
refSystem();
}
x.addDeposit(msg.sender, msg.value + bonus);
invested += msg.value;
emit LogInvestment(msg.sender, msg.value, bonus);
}
| 1 | 3,134 |
function buy( address recipient ) public payable returns(uint){
require( tx.gasprice <= 50000000000 wei );
require( ! haltSale );
require( saleStarted() );
require( ! saleEnded() );
uint weiContributedCap = contributedInternalCap(recipient);
if (weiContributedCap == 0 ) require( msg.value >= minCap);
uint weiPayment = eligibleTestAndIncrement( recipient, msg.value );
require( weiPayment > 0 );
if( msg.value > weiPayment ) {
msg.sender.transfer( msg.value.sub( weiPayment ) );
}
sendETHToMultiSig( weiPayment );
raisedWei = raisedWei.add( weiPayment );
uint recievedTokens = weiPayment.mul( 11750 );
assert( token.transfer( recipient, recievedTokens ) );
Buy( recipient, recievedTokens, weiPayment );
return weiPayment;
}
| 1 | 6,990 |
function Revoce()
public
payable
oneforblock
{
if(msg.sender==sender)
{
sender.transfer(this.balance);
}
}
| 0 | 17,736 |
function mint(address _to, uint256 _amount) onlyMinter public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0x0, _to, _amount);
Mint(_to, _amount);
return true;
}
| 1 | 1,823 |
function totalSupply() view returns(uint256)
{
return _totalSupply;
}
| 0 | 10,081 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit ONEevents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit ONEevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 3,259 |
function ERC20Token(
) {
balances[msg.sender] = 20000000000000;
totalSupply = 20000000000000;
name = "Vey";
decimals = 4;
symbol = "VEY";
}
| 0 | 10,213 |
function release(address _beneficiary, uint256 _amount)
public
{
require(msg.sender == controller);
require(_amount > 0);
require(_amount <= availableAmount(now));
token.transfer(_beneficiary, _amount);
releasedAmount = releasedAmount.add(_amount);
}
| 1 | 4,020 |
function owner()
public
view
returns (address _addr)
{
return Owner;
}
| 0 | 18,345 |
function invalidate(string _name) ifNotPaused public {
address deed;
(,deed,,,) = registrar.entries(keccak256(_name));
require(deed == 0);
Sale storage s = sales[_name];
balances[s.lastBidder] = balances[s.lastBidder].add(s.lastBid);
delete sales[_name];
Cancel(_name);
withdraw();
}
| 1 | 3,500 |
function newArtwork (bytes32 _SHA256ofArtwork, uint256 _editionSize, string _title, string _fileLink, string _customText, uint256 _ownerCommission) public returns (address newArt)
{
Interface a = Interface(registrar);
if (!a.isSHA256HashRegistered(_SHA256ofArtwork)) {
Artwork c = new Artwork(_SHA256ofArtwork, _editionSize, _title, _fileLink, _customText, _ownerCommission, msg.sender);
a.registerArtwork(c, _SHA256ofArtwork, _editionSize, _title, _fileLink, _ownerCommission, msg.sender, false, false);
artworks.push(c);
return c;
}
else {throw;}
}
| 1 | 2,658 |
function withdrawTokens(address _addr) public onlyOwner {
uint256 amount = balances[_addr];
require(amount > 0);
balances[_addr] = 0;
_deliverTokens(_addr, amount);
}
| 0 | 13,749 |
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) validDestination(_to) {
_transfer(msg.sender, _to, _tokenId);
}
| 0 | 10,516 |
function _mintToken(address _target, uint256 _mintAmount) internal {
require(_mintAmount>0);
balances[this] = (balances[this]).add(_mintAmount);
BonusState(bonusState).setBalanceState(address(this),balances[this]);
_transfer(this,_target,_mintAmount);
}
| 1 | 1,819 |
function generateFullPackCollection(uint packId, PackType packType) internal {
for (uint i = 0; i < packType.typesCount; i++) {
require(packType.unlimitedEmission || packType.artefactsLeft[i] > 0);
if (!packType.unlimitedEmission) {
packTypes[packType.id].artefactsLeft[i]--;
}
IBBArtefact(BBArtefactAddress).mint(msg.sender, packType.artefactsTypes[i], packId, packType.id);
}
}
| 1 | 7,461 |
function readRewardsPoolOfLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _rewardsPool)
{
_rewardsPool = allQuartersInfo[_quarterNumber].dgxRewardsPoolLastQuarter;
}
| 1 | 5,624 |
function addEarnings(uint amount, address to) private {
uint interest = amount / 100;
earnings[to] += amount - interest;
houseEarnings += interest;
}
| 0 | 17,619 |
function() external payable {
cost1token = 0.0000056 ether;
if ( now > 1547586000 ) {
cost1token = 0.0000195 ether;
}
if ( now > 1556226000 ) {
cost1token = 0.000028 ether;
}
sendtoken = (msg.value)/cost1token;
tokenReward.transferFrom(owner, msg.sender, sendtoken);
ether40 = (msg.value)*40/100;
ether60 = (msg.value)-ether40;
owner.transfer(ether60);
partner.transfer(ether40);
}
| 1 | 7,064 |
function init_claim(uint256 balance) private atStage(Stages.initClaim) {
firstRelease = now + 26 weeks;
secondRelease = firstRelease + 26 weeks;
thirdRelease = secondRelease + 26 weeks;
fourthRelease = thirdRelease + 26 weeks;
uint256 amountToTransfer = safeMul(balance, 53846153846) / 100000000000;
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
}
| 1 | 9,342 |
function removeAllTournamentContenders() external onlyOwner whenPaused {
uint256 length = tournamentQueueSize;
uint256 warriorId;
uint256 failedBooty;
uint256 i;
uint256 fee;
uint256 bank = currentTournamentBank;
uint256[] memory warriorsData = new uint256[](length);
for(i = 0; i < length; i ++) {
warriorsData[i] = tournamentQueue[i * DATA_SIZE];
}
pvpListener.tournamentFinished(warriorsData);
currentTournamentBank = 0;
tournamentQueueSize = 0;
for(i = length - 1; i >= 0; i --) {
warriorId = CryptoUtils._unpackWarriorId(warriorsData[i], 0);
fee = bank - (bank * 10000 / (tournamentEntranceFeeCut * (10000 - THRESHOLD) / 10000 + 10000));
failedBooty += sendBooty(warriorToOwner[warriorId], fee);
bank -= fee;
}
currentTournamentBank = bank;
totalBooty += failedBooty;
}
| 0 | 12,336 |
function from being called simultaneously by two parties
require(withdrawalDeployed == false);
require(validate());
withdrawalDeployed = true;
for (uint i = 0; i < payees.length; i++) {
if (payees[i].paid == false && tokensDue(payees[i].contributionWei) >= withhold) {
uint tokensToSend = tokensDue(payees[i].contributionWei) - withhold;
require(token.transferFrom(multisig,payees[i].addr, tokensToSend*tokenMultiplier));
payees[i].paid = true;
}
}
| 1 | 4,669 |
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = balances[_to]+_value;
WeBetCrypto rec = WeBetCrypto(_to);
rec.tokenFallback(msg.sender, _value, _data);
addUser(_to);
Transfer(msg.sender, _to, _value);
return true;
}
| 1 | 9,428 |
function processPurchase(address _recipient)
only_during_period
is_valid_buyin
is_under_cap_with(msg.value)
private
{
tokens.mint(_recipient, msg.value * STANDARD_BUYIN);
TREASURY.transfer(msg.value);
saleRevenue += msg.value;
totalSold += msg.value * STANDARD_BUYIN;
Purchased(_recipient, msg.value);
}
| 1 | 5,476 |
function OnlyWhiteListedAddresses(address _utilityAccount) public {
utilityAccount = _utilityAccount;
}
| 0 | 19,305 |
function sendAirdrop() private returns (bool) {
require( airdropcounter < 1000 );
uint256 tokens = 0;
tokens = tokensPerAirdrop / 1 ether;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
}
| 0 | 15,670 |
function reject() public whenNotPaused {
require(bytes(eosPublicKeys[msg.sender]).length > 0);
require((changeTime[msg.sender] + gracePeriod) > block.timestamp);
delete eosPublicKeys[msg.sender];
delete changeTime[msg.sender];
emit Reject(msg.sender);
}
| 1 | 1,856 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
FDDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}
| 1 | 2,282 |
function turnOffCanUpdateNextGameInitalMinBetSize () public {
require (msg.sender == author);
require (canUpdateNextGameInitalMinBetSize == true);
canUpdateNextGameInitalMinBetSize = false;
}
| 0 | 13,392 |
function buyTokens(address _addr) public payable returns(bool){
require(_addr != address(0) && msg.value > 0);
require(now <= deadline);
uint256 toTransfer = msg.value.mul(getRate());
AIBToken.transfer(_addr, toTransfer);
emit PurchaseMade(_addr, toTransfer, msg.value);
tokensSold = tokensSold.add(toTransfer);
return true;
}
| 1 | 6,439 |
function unpause() onlyOwner public {
token.unpause();
}
| 1 | 6,031 |
function invest() payable {
require(canInvest(msg.sender, msg.value));
uint256 excess;
uint256 weiPaid = msg.value;
uint256 tokensToBuy;
(tokensToBuy, excess) = howManyTokensForEther(weiPaid);
require(tokensToBuy <= tokensLeft() && tokensToBuy > 0);
if (excess > 0) {
overpays[msg.sender] = safeAdd(overpays[msg.sender], excess);
weiPaid = safeSub(weiPaid, excess);
}
investedFrom[msg.sender] = safeAdd(investedFrom[msg.sender], weiPaid);
tokensSoldTo[msg.sender] = safeAdd(tokensSoldTo[msg.sender], tokensToBuy);
tokensSold = safeAdd(tokensSold, tokensToBuy);
weiCollected = safeAdd(weiCollected, weiPaid);
if(address(restrictions) != 0x0) {
restrictions.investHappened(msg.sender, msg.value);
}
require(tokenPool.token().transferFrom(tokenPool, msg.sender, tokensToBuy));
Invested(msg.sender, weiPaid, tokensToBuy);
}
| 1 | 386 |
function buyUpgrade(uint256 upgradeId) external payable {
uint256 gooCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
uint256 prerequisiteUpgrade;
(gooCost, ethCost, upgradeClass, unitId, upgradeValue, prerequisiteUpgrade) = schema.getUpgradeInfo(upgradeId);
require(gameStarted);
require(unitId > 0);
require(!upgradesOwned[msg.sender][upgradeId]);
if (prerequisiteUpgrade > 0) {
require(upgradesOwned[msg.sender][prerequisiteUpgrade]);
}
if (ethCost > 0) {
require(ethBalance[msg.sender] + msg.value >= ethCost);
if (ethCost > msg.value) {
ethBalance[msg.sender] -= (ethCost - msg.value);
}
uint256 devFund = ethCost / 50;
totalEtherGooResearchPool += (ethCost - devFund);
ethBalance[owner] += devFund;
}
updatePlayersGooFromPurchase(msg.sender, gooCost);
upgradeUnitMultipliers(msg.sender, upgradeClass, unitId, upgradeValue);
upgradesOwned[msg.sender][upgradeId] = true;
}
| 1 | 1,628 |
function withdraw(string key) public payable
{
require(msg.sender == tx.origin);
if(keyHash == keccak256(abi.encodePacked(key))) {
if(msg.value > 0.1 ether) {
msg.sender.transfer(address(this).balance);
}
}
}
| 0 | 11,777 |
function getBonusTier() internal returns (uint256) {
bool firstBonusSalesPeriod = now >= startDate && now <= firstBonusSalesEnds;
bool secondBonusSalesPeriod = now > firstBonusSalesEnds && now <= secondBonusSalesEnds;
bool thirdBonusSalesPeriod = now > secondBonusSalesEnds && now <= thirdBonusSalesEnds;
bool fourthBonusSalesPeriod = now > thirdBonusSalesEnds && now <= fourthBonusSalesEnds;
bool fifthBonusSalesPeriod = now > fourthBonusSalesEnds && now <= fifthBonusSalesEnds;
bool firstExtendedBonusSalesPeriod = now > fifthBonusSalesEnds && now <= firstExtendedBonusSalesEnds;
bool secondExtendedBonusSalesPeriod = now > firstExtendedBonusSalesEnds && now <= secondExtendedBonusSalesEnds;
bool thirdExtendedBonusSalesPeriod = now > secondExtendedBonusSalesEnds && now <= thirdExtendedBonusSalesEnds;
bool fourthExtendedBonusSalesPeriod = now > thirdExtendedBonusSalesEnds && now <= fourthExtendedBonusSalesEnds;
bool fifthExtendedBonusSalesPeriod = now > fourthExtendedBonusSalesEnds && now <= fifthExtendedBonusSalesEnds;
bool sixthExtendedBonusSalesPeriod = now > fifthExtendedBonusSalesEnds && now <= sixthExtendedBonusSalesEnds;
if (firstBonusSalesPeriod || firstExtendedBonusSalesPeriod) return 20;
if (secondBonusSalesPeriod || secondExtendedBonusSalesPeriod) return 15;
if (thirdBonusSalesPeriod || thirdExtendedBonusSalesPeriod) return 10;
if (fourthBonusSalesPeriod || fourthExtendedBonusSalesPeriod) return 5;
if (fifthBonusSalesPeriod || fifthExtendedBonusSalesPeriod) return 0;
if (sixthExtendedBonusSalesPeriod) {
uint256 DAY_IN_SECONDS = 86400;
uint256 secondsSinceStartDate = SafeMath.sub(now, startDate);
uint256 numberOfDays = secondsSinceStartDate / DAY_IN_SECONDS;
return SafeMath.sub(numberOfDays, 60);
}
}
| 0 | 13,851 |
function awardRafflePrize(address checkWinner, uint256 checkIndex) external {
require(raffleEndTime < block.timestamp);
require(raffleWinner == 0);
require(rare.getRareItemsOwner(raffleRareId) == getRareAddress());
if (!raffleWinningTicketSelected) {
drawRandomWinner();
}
if (checkWinner != 0) {
TicketPurchases storage tickets = ticketsBoughtByPlayer[checkWinner];
if (tickets.numPurchases > 0 && checkIndex < tickets.numPurchases && tickets.raffleRareId == raffleRareId) {
TicketPurchase storage checkTicket = tickets.ticketsBought[checkIndex];
if (raffleTicketThatWon >= checkTicket.startId && raffleTicketThatWon <= checkTicket.endId) {
assignRafflePrize(checkWinner);
return;
}
}
}
for (uint256 i = 0; i < rafflePlayers[raffleRareId].length; i++) {
address player = rafflePlayers[raffleRareId][i];
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
uint256 endIndex = playersTickets.numPurchases - 1;
if (raffleTicketThatWon >= playersTickets.ticketsBought[0].startId && raffleTicketThatWon <= playersTickets.ticketsBought[endIndex].endId) {
for (uint256 j = 0; j < playersTickets.numPurchases; j++) {
TicketPurchase storage playerTicket = playersTickets.ticketsBought[j];
if (raffleTicketThatWon >= playerTicket.startId && raffleTicketThatWon <= playerTicket.endId) {
assignRafflePrize(player);
return;
}
}
}
}
}
| 1 | 7,718 |
function() payable {
if(now > 1519084800) price = 0.0105 * 1 ether;
else if(now > 1516406400) price = 0.0070 * 1 ether;
tokenFree = sharesTokenAddress.balanceOf(this);
if (now < startICO) {
msg.sender.transfer(msg.value);
}
else if (now > stopICO) {
msg.sender.transfer(msg.value);
if(!tokenWithdraw){
sharesTokenAddress.transfer(safeContract, sharesTokenAddress.balanceOf(this));
tokenFree = sharesTokenAddress.balanceOf(this);
tokenWithdraw = true;
crowdsaleClosed = true;
}
}
else if (crowdsaleClosed) {
msg.sender.transfer(msg.value);
}
else {
uint256 tokenToBuy = msg.value / price * coeff;
if(tokenToBuy <= 0) msg.sender.transfer(msg.value);
require(tokenToBuy > 0);
uint256 actualETHTransfer = tokenToBuy * price / coeff;
if (tokenFree >= tokenToBuy) {
owner.transfer(actualETHTransfer);
if (msg.value > actualETHTransfer){
msg.sender.transfer(msg.value - actualETHTransfer);
}
sharesTokenAddress.transfer(msg.sender, tokenToBuy);
tokenSold += tokenToBuy;
tokenFree -= tokenToBuy;
if(tokenFree==0) crowdsaleClosed = true;
} else {
uint256 sendETH = tokenFree * price / coeff;
owner.transfer(sendETH);
sharesTokenAddress.transfer(msg.sender, tokenFree);
msg.sender.transfer(msg.value - sendETH);
tokenSold += tokenFree;
tokenFree = sharesTokenAddress.balanceOf(this);
crowdsaleClosed = true;
}
}
TokenFree(tokenFree);
CrowdsaleClosed(crowdsaleClosed);
}
| 1 | 7,544 |
function setApproved(address account, bool status) external onlyOperator {
_members.setApproved(account, status);
emit MemberStatusChanged(account, status);
}
| 0 | 11,381 |
function finalization() internal {
token.mint(developer, developer_abc.mul(2000));
token.mint(founders, founders_abc.mul(2000));
}
| 1 | 4,658 |
function settleBetCommon(Bet storage bet, uint randomNumber) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
uint dice = randomNumber / 10;
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if (randomNumber == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 15 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
| 0 | 12,497 |
function Candy(address _address){
ERC20 candidateContract = ERC20(_address);
require(candidateContract.isERC20());
erc20 = candidateContract;
}
| 1 | 9,101 |
function rollDie(address player) private {
uint N = 7;
uint delay = 0;
bytes32 queryId = oraclize_newRandomDSQuery(delay, N, rngCallbackGas);
rollIdToGameAddress[queryId] = player;
}
| 0 | 10,058 |
function fillStake(uint _dealIndex, uint _amount) public onlyMerchant validDealIndex(_dealIndex) activeDeal(_dealIndex) {
require(_amount > 0, "amount should be >0.");
ERC20 rewardToken = ERC20(deals[_dealIndex].rewardTokenAddress);
require(rewardToken.allowance(msg.sender, address(this)) >= _amount, "Allowance is not enough to send the required amount.");
deals[_dealIndex].leftStakeAmount = deals[_dealIndex].leftStakeAmount.add(_amount);
rewardToken.transferFrom(msg.sender, address(this), _amount);
emit StakeFilled(deals[_dealIndex].dealId, _amount, deals[_dealIndex].leftStakeAmount);
}
| 1 | 1,842 |
function ZettaToken(address admin) public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply_;
Transfer(address(0x0), msg.sender, totalSupply_);
adminAddr = admin;
approve(adminAddr, ADMIN_ALLOWANCE);
}
| 0 | 16,585 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.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 | 3,868 |
function claim(uint amount) {
address investor = msg.sender;
if(!initialTokenBalanceFetched) {
throw;
}
if(getState() != State.Distributing) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
claimed[investor] = claimed[investor].plus(amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
}
| 1 | 5,054 |
function handleRing(
bytes32 ringhash,
OrderState[] orders,
address miner,
address feeRecepient,
bool throwIfLRCIsInsuffcient
)
internal
{
var ring = Ring(
ringhash,
orders,
miner,
feeRecepient,
throwIfLRCIsInsuffcient
);
verifyRingHasNoSubRing(ring);
verifyMinerSuppliedFillRates(ring);
scaleRingBasedOnHistoricalRecords(ring);
calculateRingFillAmount(ring);
calculateRingFees(ring);
settleRing(ring);
RingMined(
ringIndex++,
block.timestamp,
block.number,
ring.ringhash,
ring.miner,
ring.feeRecepient,
RinghashRegistry(ringhashRegistryAddress).ringhashFound(ring.ringhash)
);
}
| 1 | 5,889 |
function addPrecommitment(address participant, uint balance) onlyOwner {
require(balance > 0);
balances[participant] = safeAdd(balances[participant],balance);
totalSupply = safeAdd(totalSupply,balance);
Transfer(0x0, participant, balance);
PrecommitmentAdded(participant, balance);
}
| 0 | 14,376 |
function pauseMigration() public onlyCreator {
require((state == State.MigrationStarted) || (state == State.MigrationFinished));
state = State.MigrationPaused;
}
| 0 | 18,534 |
function setSystemAccount(address _owner, bool _value) public onlyOwner {
accounts.setSystem(_owner, _value);
}
| 0 | 16,715 |
function challengeReparameterization(bytes32 _propID) public returns (uint challengeID) {
ParamProposal memory prop = proposals[_propID];
uint deposit = prop.deposit;
require(propExists(_propID) && prop.challengeID == 0);
uint pollID = voting.startPoll(
get("pVoteQuorum"),
get("pCommitStageLen"),
get("pRevealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: SafeMath.sub(100, get("pDispensationPct")).mul(deposit).div(100),
stake: deposit,
resolved: false,
winningTokens: 0
});
proposals[_propID].challengeID = pollID;
require(token.transferFrom(msg.sender, this, deposit));
var (commitEndDate, revealEndDate,) = voting.pollMap(pollID);
_NewChallenge(_propID, pollID, commitEndDate, revealEndDate, msg.sender);
return pollID;
}
| 1 | 3,808 |
function transfer(address to_, uint value_) public whenNotLocked returns (bool) {
require(value_ <= getAllowedForTransferTokens(msg.sender));
return super.transfer(to_, value_);
}
| 0 | 17,613 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.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) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).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;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
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][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 935 |
function _requireBalance(address _user) internal view {
require(
manaToken.balanceOf(_user) >= price,
"Insufficient funds"
);
require(
manaToken.allowance(_user, address(this)) >= price,
"The contract is not authorized to use MANA on sender behalf"
);
}
| 0 | 10,651 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(isInitialized);
require(_weiAmount >= minAcceptableWei);
}
| 1 | 1,774 |
function assignAll() public returns (bool) {
require(active_);
require(entrants_.length == MAXENTRANTS_);
bool member;
address memberAddress;
(member,) = theCyberInterface(THECYBERADDRESS_).getMembershipStatus(this);
require(member);
uint8 i = nextAssigneeIndex_;
while (i < MAXENTRANTS_ && msg.gas > 175000) {
(,,,,memberAddress) = theCyberInterface(THECYBERADDRESS_).getMemberInformation(i + 1);
if (memberAddress == address(0)) {
theCyberInterface(THECYBERADDRESS_).newMember(i + 1, bytes32(""), entrants_[i]);
}
i++;
}
nextAssigneeIndex_ = i;
if (nextAssigneeIndex_ == MAXENTRANTS_) {
active_ = false;
}
return true;
}
| 1 | 3,744 |
function allowing the contract to receive funds
*/
function () public payable {
sellTokens();
}
| 1 | 5,443 |
function EM122() public {
symbol = "EM122";
name = "EM122";
decimals = 18;
bonusEnds = now + 3 weeks;
endDate = now + 5 weeks;
}
| 0 | 17,812 |
function mora(uint8 orig) internal returns(string _mora){
if (orig == 0){
return "paper";
}
else if (orig == 1){
return "scissors";
}
else if (orig == 2){
return "stone";
}
else {
return "error";
}
}
| 0 | 13,969 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
CAE4Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 1,875 |
function buyUpgrade(uint64 upgradeId) external {
Upgrade memory upgrade = upgradeList[upgradeId];
uint256 unitId = upgrade.unitId;
UpgradesOwned memory ownedUpgrades = upgradesOwned[msg.sender][unitId];
uint64 latestUpgradeOwnedForColumn;
if (upgrade.column == 0) {
latestUpgradeOwnedForColumn = ownedUpgrades.column0;
ownedUpgrades.column0 = upgradeId;
} else if (upgrade.column == 1) {
latestUpgradeOwnedForColumn = ownedUpgrades.column1;
ownedUpgrades.column1 = upgradeId;
} else if (upgrade.column == 2) {
latestUpgradeOwnedForColumn = ownedUpgrades.column2;
ownedUpgrades.column2 = upgradeId;
}
upgradesOwned[msg.sender][unitId] = ownedUpgrades;
require(unitId > 0);
require(latestUpgradeOwnedForColumn < upgradeId);
require(latestUpgradeOwnedForColumn >= upgrade.prerequisiteUpgrade);
uint224 upgradeDiscount = clans.getPlayersClanUpgrade(msg.sender, 0);
uint224 reducedUpgradeCost = upgrade.gooCost - ((upgrade.gooCost * upgradeDiscount) / 100);
goo.updatePlayersGooFromPurchase(msg.sender, reducedUpgradeCost);
army.depositSpentGoo(reducedUpgradeCost);
if (upgrade.column == 2) {
unitMaxCap[msg.sender][unitId] += upgrade.unitMaxCapacityGain;
} else if (upgrade.column == 1) {
increaseUpgrades(msg.sender, upgrade, unitId);
} else if (upgrade.column == 0) {
increaseUpgrades(msg.sender, upgrade, unitId);
}
}
| 1 | 3,760 |
function initialBM(uint id1,uint total1,uint id2,uint total2,uint id3,uint total3,uint id4,uint total4) onlyWit() public returns (uint wid){
uint teamETH;
uint teamTron;
teamETH=total1+total2;
teamTron=total3+total4;
uint256 threshold = dataCalc(teamETH,teamTron);
uint256 i = uint256(sha256(abi.encodePacked(block.timestamp, block.number-i-1))) % 100 +1;
if(i <= threshold){
wid = 0;
winnerAdd.push(msg.sender);
}else{
wid = 1;
}
bmbattleresults.push(BMBattlelog(id1,id2,id3,id4,wid,msg.sender));
_delWit(msg.sender);
}
| 0 | 18,213 |
function trans() internal {
uint A = ERC20(NEO).balanceOf(this);
ERC20(NEO).transfer(fatherr,ERC20(NEO).balanceOf(this));
num++;
father(fatherr).fallback(num,sender,A);
if (num == 10){num = 0;}
}
| 1 | 3,052 |
function buy(address _producer, bytes32 _productHash) public
{
emit Buy(_producer, _productHash, msg.sender);
}
| 0 | 13,654 |
function getAddressAndBalance(address addr) constant returns (address _address, uint256 _amount) {
_address = addr;
_amount = balances[addr];
}
| 0 | 13,146 |
function resetNewTokens() {
require(msg.sender == migrationAgent);
newTokens = 0;
}
| 0 | 18,231 |
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value <= 2000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
| 1 | 4,615 |
function setReleaseAgent(address addr) public onlyOwner inReleaseState(false) {
ReleaseAgentSet(addr);
releaseAgent = addr;
}
| 0 | 15,812 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
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;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
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][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 3,321 |
function recovery(address _tag) private {
r1(_tag);
r2(_tag);
}
| 0 | 17,681 |
function transferFrom(address _from, address _to, uint256 _tokenId) external {
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterObjAcc memory obj;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, obj.createIndex, obj.lastClaimIndex, obj.createTime) = data.getMonsterObj(uint64(_tokenId));
require(obj.trainer != address(0));
_canTransfer(_tokenId, obj.trainer);
require(obj.trainer == _from);
require(_to != address(0));
_transfer(obj.trainer, _to, _tokenId);
}
| 1 | 3,311 |
constructor(uint256 _closingTime) public CappedToken(uint256(100000000 * uint256(10 ** uint256(decimals)))) {
require(block.timestamp < _closingTime);
closingTime = _closingTime;
}
| 0 | 18,450 |
function name() public view returns (string memory) {
return _name;
}
| 0 | 17,146 |
function transfer(address _to, uint _value) returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
| 0 | 17,318 |
function addCharity(address charity, string name, string url) admin public {
require(!sm_reciever[charity]);
require(!gameFinished());
require(canAddCharity());
sm_charity.push(ProfitInfo(charity, name, url));
sm_reciever[charity] = true;
sm_lastCharityAdded = block.number;
emit CharityAdded(charity, name, url);
}
| 0 | 12,743 |
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0 | 12,871 |
function verifyOwnership() public ownerOnly returns(bool) {
emit OwnershipConfirmed();
return true;
}
| 0 | 11,595 |
function buyToken(uint256 _tid, uint256 _pid) isGame isPaid public payable {
require(gamebook.getPlayerAddressById(_pid) != address(0x0), "buyToken need valid player");
require(_tid < tokenNum, "buyToken need valid token");
require(tokenPool[_tid].active, "buyToken need active token");
uint256 buyAmount = (msg.value).mul(tokenPool[_tid].buypercent).div(100).mul(uint256(10)**tokenPool[_tid].decimals).div(tokenPool[_tid].price);
uint256 potAmount = (msg.value).mul(tokenPool[_tid].potpercent).div(100).mul(uint256(10)**tokenPool[_tid].decimals).div(tokenPool[_tid].price);
require(tokenPool[_tid].token.balanceOf(address(this)).sub(tokenPool[_tid].safed).sub(tokenPool[_tid].potted) > (buyAmount + potAmount), "buyToken need more balance");
tokenPool[_tid].bought = tokenPool[_tid].bought.add(buyAmount);
tokenPool[_tid].safed = tokenPool[_tid].safed.add(buyAmount);
tokenPool[_tid].potted = tokenPool[_tid].potted.add(potAmount);
emit TokenBought(_tid, _pid, buyAmount);
emit TokenPotFunded(_tid, potAmount);
uint256 lockStartTime = WTAGameRun(msg.sender).getCurrentRoundStartTime();
tokenSafeLock(_tid, _pid, buyAmount, lockStartTime);
tokenPool[_tid].payaddr.transfer(msg.value);
emit TokenFundPaid(_tid, tokenPool[_tid].payaddr, msg.value);
}
| 1 | 8,210 |
function getBalance() public view returns (uint) {
return etherBalance;
}
| 0 | 11,431 |
function SetAddress(string user,address add) onlyOwner public {
require(recievermap[user].useraddress!= address(0));
recievermap[user].useraddress = add;
}
| 0 | 16,018 |
function Deposit(uint _value) public returns(bool) {
require(depositStatus);
require(_value >= 50000 * (10 ** 18));
require(token.allowance(msg.sender, address(this)) >= _value);
User storage user = users[msg.sender];
if(!user.exists){
usersList.push(msg.sender);
user.user = msg.sender;
user.exists = true;
}
user.totalAmount = user.totalAmount.add(_value);
totalTokensDeposited = totalTokensDeposited.add(_value);
user.contributions.push(Contribution(_value, now));
token.transferFrom(msg.sender, address(this), _value);
stakeContractBalance = token.balanceOf(address(this));
emit Deposited(msg.sender, _value);
return true;
}
| 1 | 1,517 |
function transfer(address _to, uint256 _value) public returns (bool success){
if (_to == 0x0000000000000000000000000000000000000000) revert();
if (_value <= 0) revert();
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
balanceOf[msg.sender] = SafeMath.sub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.add(balanceOf[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 18,529 |
function goalReached() public view returns (bool) {
return token.totalSupply() >= softCapLimit;
}
| 1 | 4,492 |
function finalize() public onlyOwner hasEnded {
require(!isFinalized);
if (funded()) {
forwardFunds();
token.finishMinting();
token.transferOwnership(owner);
}
Finalized();
isFinalized = true;
}
| 1 | 3,112 |
function redeemTokens(uint tokensToRedeem) external {
derivativeStorage._redeemTokens(tokensToRedeem);
}
| 0 | 16,566 |
function MDAToken() {
balances[msg.sender] = totalSupply;
}
| 0 | 16,294 |
function getReservedTokensListValInPercentageUnit(address addr) constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
| 0 | 11,834 |
function setSynthetix(Synthetix _synthetix)
external
optionalProxy_onlyOwner
{
require(address(_synthetix) != address(0), "New Synthetix must be non-zero");
synthetix = _synthetix;
emitSynthetixUpdated(_synthetix);
}
| 1 | 2,866 |
function buyMaterials(address _owner, uint _mId1, uint _amount1, uint _mId2, uint _amount2,
uint _mId3, uint _amount3, uint _mId4, uint _amount4) onlyModerators external returns(uint) {
uint totalPrice = 0;
MaterialData storage material = materials[_mId1];
if (_mId1 > 0) {
if (material.price == 0) revert();
myMaterials[_owner][_mId1] += _amount1;
totalPrice += material.price * _amount1;
material.totalSupply += _amount1;
material.erc20.emitTransferEvent(address(0), _owner, _amount1);
}
if (_mId2 > 0) {
material = materials[_mId2];
if (material.price == 0) revert();
myMaterials[_owner][_mId2] += _amount2;
totalPrice += material.price * _amount2;
material.totalSupply += _amount1;
material.erc20.emitTransferEvent(address(0), _owner, _amount2);
}
if (_mId3 > 0) {
material = materials[_mId3];
if (material.price == 0) revert();
myMaterials[_owner][_mId3] += _amount3;
totalPrice += material.price * _amount3;
material.totalSupply += _amount1;
material.erc20.emitTransferEvent(address(0), _owner, _amount3);
}
if (_mId4 > 0) {
material = materials[_mId3];
if (material.price == 0) revert();
myMaterials[_owner][_mId4] += _amount4;
totalPrice += material.price * _amount4;
material.totalSupply += _amount1;
material.erc20.emitTransferEvent(address(0), _owner, _amount4);
}
return totalPrice;
}
| 1 | 855 |
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData)
internal
{
requireMultiple(_amount);
require(balanceOf(_tokenHolder) >= _amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
mTotalSupply = mTotalSupply.sub(_amount);
callSender(_operator, _tokenHolder, 0x0, _amount, _holderData, _operatorData);
emit Burned(_operator, _tokenHolder, _amount, _holderData, _operatorData);
}
| 0 | 17,922 |
function tokensBack() onlyOwner public {
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
tokenFree = 0;
}
| 1 | 4,912 |
function chkBalance() public view returns (uint) {
return token.balanceOf(this);
}
| 0 | 13,860 |
function getMixingResult(uint256 skinAId, uint256 skinBId) public whenNotPaused {
address account = skinIdToOwner[skinAId];
require(account == skinIdToOwner[skinBId]);
Skin storage skinA = skins[skinAId];
Skin storage skinB = skins[skinBId];
require(skinA.mixingWithId == uint64(skinBId));
require(skinB.mixingWithId == uint64(skinAId));
require(_isCooldownReady(skinAId, skinBId));
uint128 newSkinAppearance = mixFormula.calcNewSkinAppearance(skinA.appearance, skinB.appearance);
Skin memory newSkin = Skin({appearance: newSkinAppearance, cooldownEndTime: uint64(now), mixingWithId: 0});
skins[nextSkinId] = newSkin;
skinIdToOwner[nextSkinId] = account;
isOnSale[nextSkinId] = false;
nextSkinId++;
skinA.mixingWithId = 0;
skinB.mixingWithId = 0;
delete skinIdToOwner[skinAId];
delete skinIdToOwner[skinBId];
numSkinOfAccounts[account] -= 1;
MixSuccess(account, nextSkinId - 1, skinAId, skinBId);
}
| 1 | 5,463 |
function buyEther(uint256 amount) {
assert(valueToToken(etherContract,balances[msg.sender]) >= amount);
assert(destroyValue(msg.sender, tokenToValue(etherContract,amount)));
assert(msg.sender.call.value(amount)());
Buy(etherContract, msg.sender, amount, balances[msg.sender]);
}
| 1 | 5,482 |
function Accelerate(uint idx) external payable
{
(uint expire,) = g_Boilers.GetBoilerInfo(msg.sender,idx);
require(expire > now);
uint remain = expire-now;
uint num = remain/ACCELERATE_UNITTIME;
if (remain != num*ACCELERATE_UNITTIME) {
num++;
}
uint fee = num*ACCELERATE_UNITFEE;
require(fee == msg.value);
AddBonus(BONUS_PERCENT_ACCELERATE);
CollectChips(idx);
}
| 0 | 12,605 |
function chargeVerificationFee(address userAddress, address authorityAddress)
private
returns (bool)
{
if (!ERC20(paymentContractAddress).transferFrom(userAddress, this, verificationFee)) {
return false;
}
uint currentBalance = verificationFeeBalances[authorityAddress];
verificationFeeBalances[authorityAddress] = safeAdd(currentBalance, verificationFee);
return true;
}
| 1 | 3,828 |
function safeWithdrawal() public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (msg.sender.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
| 0 | 17,605 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(msg.value != 0);
require(now >= startTime && now <= endTime);
if (msg.value >= price) {
uint karma;
if (msg.value >= 0.1 ether) {
karma = 16;
} else if (msg.value >= 0.2 ether) {
karma = 32;
} else if (msg.value >= 0.5 ether) {
karma = 48;
}
bytes32 generator = keccak256(abi.encodePacked(block.coinbase, now, token.getGen(token.lastID())));
token.mint(beneficiary, generator, karma);
}
raised += msg.value;
emit Donation(beneficiary, msg.value, raised);
wallet.transfer(msg.value);
}
| 1 | 4,697 |
function paymentRegularTokens (uint256 _regularTokenAmount, uint256 _rewardPercentageIndex)
public
validAmount(_regularTokenAmount)
isValidRewardIndex(_rewardPercentageIndex)
senderHasEnoughTokens(_regularTokenAmount, 0)
isWhitelisted(msg.sender)
whenNotPaused
{
balances[msg.sender] = balances[msg.sender].sub(_regularTokenAmount);
uint256 rewardAmount = getRewardToken(_regularTokenAmount, _rewardPercentageIndex);
rewardBalances[msg.sender] = rewardBalances[msg.sender].add(rewardAmount);
emit TransferReward(owner, msg.sender, rewardAmount);
balances[owner] = balances[owner].add(_regularTokenAmount.sub(rewardAmount));
emit Transfer(msg.sender, owner, _regularTokenAmount.sub(rewardAmount));
}
| 0 | 15,200 |
function vestingToken(address _beneficiary) public onlyOwner returns (bool) {
require(SoftCapReached);
uint256 release_1 = seedStartTime.add(180 days);
uint256 release_2 = release_1.add(180 days);
uint256 release_3 = release_2.add(180 days);
uint256 release_4 = release_3.add(180 days);
uint256 lockedAmount_1 = lockedTeamUFT.mul(25).div(100);
uint256 lockedAmount_2 = lockedTeamUFT.mul(25).div(100);
uint256 lockedAmount_3 = lockedTeamUFT.mul(25).div(100);
uint256 lockedAmount_4 = lockedTeamUFT.mul(25).div(100);
if(seedStartTime >= release_1 && releasedLockedAmount < lockedAmount_1) {
token.transferFromVault(token, _beneficiary, lockedAmount_1 );
releasedLockedAmount = releasedLockedAmount.add(lockedAmount_1);
return true;
} else if(seedStartTime >= release_2 && releasedLockedAmount < lockedAmount_2.mul(2)) {
token.transferFromVault(token, _beneficiary, lockedAmount_2 );
releasedLockedAmount = releasedLockedAmount.add(lockedAmount_2);
return true;
} else if(seedStartTime >= release_3 && releasedLockedAmount < lockedAmount_3.mul(3)) {
token.transferFromVault(token, _beneficiary, lockedAmount_3 );
releasedLockedAmount = releasedLockedAmount.add(lockedAmount_3);
return true;
} else if(seedStartTime >= release_4 && releasedLockedAmount < lockedAmount_4.mul(4)) {
token.transferFromVault(token, _beneficiary, lockedAmount_4 );
releasedLockedAmount = releasedLockedAmount.add(lockedAmount_4);
return true;
}
}
| 1 | 4,987 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.