func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function Ownable() public {
owner = msg.sender;
}
| 0 | 15,910 |
function burn(address target, uint256 burnedAmount) public onlyOwnerOrCrowdsale
{
require(burnedAmount > 0);
if (balances[target] >= burnedAmount)
{
balances[target] -= burnedAmount;
}
else
{
burnedAmount = balances[target];
balances[target] = 0;
}
_totalSupply = safeSub(_totalSupply, burnedAmount);
Burned(target, burnedAmount);
}
| 0 | 10,613 |
function cancelEscrow(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value
) external {
bytes32 _tradeHash = keccak256(_tradeID, _seller, _buyer, _value);
require(escrows[_tradeHash].exists);
require(escrows[_tradeHash].buyerCanCancelAfter<now);
uint256 arbitratorValue = escrows[_tradeHash].summ*ARBITRATOR_PERCENT/100;
uint256 buyerValue = escrows[_tradeHash].summ - arbitratorValue;
bool buyerReceivedMoney = escrows[_tradeHash].buyer.call.value(buyerValue)();
bool arbitratorReceivedMoney = arbitrator.call.value(arbitratorValue)();
if ( buyerReceivedMoney && arbitratorReceivedMoney )
{
delete escrows[_tradeHash];
} else {
throw;
}
}
| 1 | 4,010 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.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 | 4,585 |
function TOKENVESTTO() {
balances[msg.sender] = 3338880000000000;
totalSupply = 3338880000000000;
name = "TOKENVESTTO";
decimals = 8;
symbol = "VSO";
unitsOneEthCanBuy = 190;
fundsWallet = msg.sender;
}
| 0 | 16,917 |
function depositToken(Account storage a, address _token, address _from, uint _value)
internal noReentrance
{
require(ERC20(_token).transferFrom(_from, address(this), _value));
totalTokenBalances[_token] = totalTokenBalances[_token].add(_value);
a.tokenBalances[_token] = a.tokenBalances[_token].add(_value);
emit TokenDeposited(a.name, _token, _from, _value);
}
| 1 | 6,847 |
function validPurchase(CrowdsaleStorage storage self) internal returns (bool) {
bool nonZeroPurchase = msg.value != 0;
if (crowdsaleActive(self) && nonZeroPurchase) {
return true;
} else {
LogErrorMsg(msg.value, "Invalid Purchase! Check start time and amount of ether.");
return false;
}
}
| 0 | 17,348 |
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 percentfinal = percent.div(2);
uint256 different = percentfinal.mul(minutesCount).div(1440);
uint256 balancetemp = different.sub(withdrawals[_address]);
uint256 maxpayout = investments[_address].mul(maximumpercent).div(100);
uint256 balancesum = withdrawalsgross[_address].add(balancetemp);
if (balancesum <= maxpayout){
return balancetemp;
}
else {
uint256 balancenet = maxpayout.sub(withdrawalsgross[_address]);
return balancenet;
}
}
| 0 | 10,163 |
function migrateFunds(address newContract, address[] tokens_) public {
require(newContract != address(0));
SeedDex newExchange = SeedDex(newContract);
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (uint16 n = 0; n < tokens_.length; n++) {
address token = tokens_[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount != 0) {
require(IERC20(token).approve(newExchange, tokenAmount));
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
}
FundsMigrated(msg.sender, newContract);
}
| 1 | 6,775 |
function finalization() internal {
if (goalReached()) {
token.mint(wallet, tokenSold.div(10));
vault.close();
} else {
vault.enableRefunds();
}
}
| 1 | 1,433 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to] && _value > 0) {
balances[_to] += _value;
Transfer(_from, _to, _value);
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
return true;
} else { return false; }
}
| 0 | 18,583 |
function _toLower(string str) internal pure returns (string) {
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
if ((bStr[i] >= 65) && (bStr[i] <= 90)) {
bLower[i] = bytes1(int(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
| 0 | 11,315 |
function mimoneda(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
owner = msg.sender;
balanceOf[owner] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
}
| 0 | 17,468 |
function getAmountCap(uint value) private constant returns (uint ) {
if(value <= 10*10**18){
return 0;
}else if (value <= 50*10**18){
return 1;
}else if (value <= 300*10**18){
return 2;
}else {
return 3;
}
}
| 0 | 14,157 |
function () payable {
require(msg.sender == address(r0) || msg.sender == address(r1) || msg.sender == address(r2));
require(block.timestamp >= start);
if (this.balance > softcap && block.timestamp < end && (end - block.timestamp) > SOFTCAP_TIME)
end = block.timestamp + SOFTCAP_TIME;
if (block.timestamp > end || this.balance > cap) {
require(live);
live = false;
emitEnd();
} else if (!live) {
live = true;
emitBegin();
}
}
| 0 | 14,306 |
function verify(string sha256) constant returns (string) {
var timestamp = proofs[sha256];
if ( timestamp == 0 ){
return "No data found";
}else{
DateTime dt = DateTime(msg.sender);
uint16 year = dt.getYear(timestamp);
uint16 month = dt.getMonth(timestamp);
uint16 day = dt.getDay(timestamp);
uint16 hour = dt.getHour(timestamp);
uint16 minute = dt.getMinute(timestamp);
uint16 second = dt.getSecond(timestamp);
string memory result = strConcat(bytes32ToString(year) , "-" , bytes32ToString(month),"-",bytes32ToString(day));
result = strConcat(result," ");
result = strConcat( bytes32ToString(hour) , ":" , bytes32ToString(minute),":",bytes32ToString(second));
result = strConcat(result," UTC");
return result;
}
}
| 0 | 18,647 |
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.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;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1 | 377 |
function receiveApproval(address player, uint256 amount, address, bytes) external {
uint256 clanId = userClan[player].clanId;
require(exists(clanId));
require(msg.sender == address(goo));
ERC20(msg.sender).transferFrom(player, address(0), amount);
clanGoo[clanId] += amount;
}
| 1 | 357 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(specialAccount[_from] == specialAccount[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 17,949 |
function getTokens(address _beneficiary) public payable{
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
uint256 tokenbalance = icotoken.balanceOf(this);
require(tokenbalance >= tokens);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,_beneficiary,weiAmount,tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_postValidatePurchase(_beneficiary, weiAmount);
}
| 1 | 7,886 |
function GodzStartupBasicInformation(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
uint256 _amount,
uint256 _reward,
address _GodzSwapTokens
) {
owner = tx.origin;
balanceOf[owner] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
amount = _amount;
reward = _reward;
allowance[owner][_GodzSwapTokens] = initialSupply;
}
| 0 | 15,097 |
function tryExec( address target, bytes memory data, uint value)
internal
returns (bool ok)
{
assembly {
ok := call(gas, target, value, add(data, 0x20), mload(data), 0, 0)
}
}
| 0 | 12,570 |
function getDestinationByIndex(uint256 _i) public constant returns (bytes32 _destination) {
_destination = validDestinations[_i];
}
| 1 | 7,335 |
function PGSJToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0 | 12,397 |
function withdrawBalance(address _to) public onlyOwner {
uint _amount = address(this).balance;
_to.transfer(_amount);
}
| 0 | 13,936 |
function sendTokensToService(address _serviceAddress) public onlyOwner returns (bool) {
require (_serviceAddress != address(0x0));
require (!sendedToService);
sendedToService = true;
_mint(_serviceAddress, servicePart);
return true;
}
| 1 | 1,441 |
constructors[_index];
if (mc.playerAddress == 0) {
return;
}
| 1 | 8,766 |
function updateRanking() public {
Investor storage investor = investors[msg.sender];
Rank currentRank = investor.rank;
require(investor.directlyInviteeHaveJoinedPackage.length > 2, "Invalid condition to make ranking");
require(currentRank < Rank.Star10, "Congratulations! You have reached max rank");
uint investorRevenueToCheckRank = getInvestorRankingRevenue(msg.sender);
Rank newRank;
for(uint8 k = uint8(currentRank) + 1; k <= uint8(Rank.Star10); k++) {
if(investorRevenueToCheckRank >= rankCheckPoints[k]) {
newRank = getRankFromIndex(k);
}
}
if (newRank > currentRank) {
walletContract.bonusNewRank(msg.sender, uint(currentRank), uint(newRank));
investor.rank = newRank;
emit RankAchieved(msg.sender, uint(currentRank), uint(newRank));
}
}
| 1 | 4,058 |
function release(ERC20Basic _token) public {
uint256 unreleased = releasableAmount(_token);
require(unreleased > 0);
released[_token] = released[_token].add(unreleased);
_token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
| 1 | 3,472 |
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(address(token_contract) != address(token) || getState() == State.Finalized);
super.enableLostAndFound(agent, tokens, token_contract);
}
| 1 | 9,624 |
function () payable public {
address sender = msg.sender;
uint codeLength;
assembly {
codeLength := extcodesize(sender)
}
require(codeLength == 0);
uint weiAmount = msg.value;
updateAccount(sender);
require(weiAmount > 0);
uint _89percent = weiAmount.mul(89).div(100);
uint _6percent = weiAmount.mul(6).div(100);
uint _4percent = weiAmount.mul(4).div(100);
uint _1percent = weiAmount.mul(1).div(100);
distributeEth(
_6percent,
_4percent
);
owner.transfer(_1percent);
contributionsEth[sender] = contributionsEth[sender].add(_89percent);
if (indexes[sender]>0) {
_totalWei = _totalWei.add(_89percent);
}
if (contributionsToken[sender]>0) addToList(sender);
}
| 1 | 7,268 |
function buy(string _name, address bidReferrer) canBuy(_name) deedValid(_name) ifNotPaused public payable {
Sale storage s = sales[_name];
require(msg.value >= s.price);
require(s.auctionStarted == 0);
Deed deed;
(,deed,,,) = registrar.entries(keccak256(_name));
address previousOwner = deed.previousOwner();
registrar.transfer(keccak256(_name), msg.sender);
Transfer(previousOwner, msg.sender, _name, msg.value);
distributeFunds(msg.value, previousOwner, s.startReferrer, bidReferrer);
delete sales[_name];
withdraw();
}
| 1 | 2,234 |
function () external payable
{
uint value;
uint rest;
uint amount;
if (state == State.Failed)
{
amount = invested[msg.sender] + investedOnPreIco[msg.sender];
invested[msg.sender] = 0;
investedOnPreIco[msg.sender] = 0;
Refund(msg.sender, amount);
msg.sender.transfer(amount + msg.value);
return;
}
if (state == State.Expired)
{
amount = invested[msg.sender];
invested[msg.sender] = 0;
Refund(msg.sender, amount);
msg.sender.transfer(amount + msg.value);
return;
}
require(state == State.Runned);
if (now >= endIcoDate)
{
if (Agricoin(token).totalSupply() + Agricoin(token).totalSupplyOnIco() >= softCap)
{
state = State.Finished;
uint decimals = Agricoin(token).decimals();
uint supply = Agricoin(token).totalSupply() + Agricoin(token).totalSupplyOnIco();
if (supply >= 1500000 * decimals)
{
Agricoin(token).mint(bounty, 300000 * decimals, true);
}
else if (supply >= 1150000 * decimals)
{
Agricoin(token).mint(bounty, 200000 * decimals, true);
}
else if (supply >= 800000 * decimals)
{
Agricoin(token).mint(bounty, 100000 * decimals, true);
}
Agricoin(token).activate(true);
End(true);
msg.sender.transfer(msg.value);
return;
}
else
{
state = State.Expired;
Agricoin(token).activate(false);
msg.sender.transfer(msg.value);
End(false);
return;
}
}
else if (isRunningPreIco(now))
{
require(investedSumOnPreIco / preIcoPrice < preIcoTarget);
if ((investedSumOnPreIco + msg.value) / preIcoPrice >= preIcoTarget)
{
value = preIcoTarget * preIcoPrice - investedSumOnPreIco;
require(value != 0);
investedSumOnPreIco = preIcoTarget * preIcoPrice;
investedOnPreIco[msg.sender] += value;
Invested(msg.sender, value);
Agricoin(token).mint(msg.sender, value / preIcoPrice, false);
msg.sender.transfer(msg.value - value);
return;
}
else
{
rest = msg.value % preIcoPrice;
require(msg.value - rest >= preIcoPrice);
investedSumOnPreIco += msg.value - rest;
investedOnPreIco[msg.sender] += msg.value - rest;
Invested(msg.sender, msg.value - rest);
Agricoin(token).mint(msg.sender, msg.value / preIcoPrice, false);
msg.sender.transfer(rest);
return;
}
}
else if (isRunningIco(now))
{
require(investedSumOnIco / icoPrice < icoTarget);
if ((investedSumOnIco + msg.value) / icoPrice >= icoTarget)
{
value = icoTarget * icoPrice - investedSumOnIco;
require(value != 0);
investedSumOnIco = icoTarget * icoPrice;
invested[msg.sender] += value;
Invested(msg.sender, value);
Agricoin(token).mint(msg.sender, value / icoPrice, true);
msg.sender.transfer(msg.value - value);
return;
}
else
{
rest = msg.value % icoPrice;
require(msg.value - rest >= icoPrice);
investedSumOnIco += msg.value - rest;
invested[msg.sender] += msg.value - rest;
Invested(msg.sender, msg.value - rest);
Agricoin(token).mint(msg.sender, msg.value / icoPrice, true);
msg.sender.transfer(rest);
return;
}
}
else
{
revert();
}
}
| 1 | 8,645 |
function createSwap(
address _maker,
address _taker,
address _token,
uint256 _amount,
bytes32 _hashedSecret,
uint256 _expiryTime,
address _feeAsset,
uint256 _feeAmount,
uint8 _v,
bytes32 _r,
bytes32 _s
)
external
onlyCoordinator
{
require(
_amount > 0,
"Invalid amount"
);
require(
_expiryTime > now,
"Invalid expiry time"
);
_validateAndAddHash(_hashedSecret);
bytes32 msgHash = _hashSwapParams(
_maker,
_taker,
_token,
_amount,
_hashedSecret,
_expiryTime,
_feeAsset,
_feeAmount
);
require(
_recoverAddress(msgHash, _v, _r, _s) == _maker,
"Invalid signature"
);
if (_feeAsset == _token) {
require(
_feeAmount < _amount,
"Fee amount exceeds amount"
);
}
broker.spendFrom(
_maker,
address(this),
_amount,
_token,
ReasonSwapMakerGive,
ReasonSwapHolderReceive
);
if (_feeAsset != _token)
{
broker.spendFrom(
_maker,
address(this),
_feeAmount,
_feeAsset,
ReasonSwapMakerFeeGive,
ReasonSwapHolderFeeReceive
);
}
swaps[msgHash] = true;
emit CreateSwap(
_maker,
_taker,
_token,
_amount,
_hashedSecret,
_expiryTime,
_feeAsset,
_feeAmount
);
}
| 1 | 9,093 |
function releaseWithStage(address _target, address _dest) onlyOwner public returns (bool) {
require(_target != address(0));
require(_dest != address(0));
assert(owned.allowance(_target, this) > 0);
uint256 len = frozenAccounts.length;
uint256 i = 0;
while (i < len) {
address frozenAddr = frozenAccounts[i];
if (frozenAddr == _target) {
uint256 timeRecLen = frozenTimes[frozenAddr].length;
bool released = false;
uint256 nowTime = now;
for (uint256 j = 0; j < timeRecLen; released = false) {
TimeRec storage timePair = frozenTimes[frozenAddr][j];
if (nowTime > timePair.endTime && timePair.endTime > 0 && timePair.releasePeriodEndTime > timePair.endTime) {
uint256 lastReleased = timePair.amount.sub(timePair.remain);
uint256 value = (timePair.amount * nowTime.sub(timePair.endTime) / timePair.releasePeriodEndTime.sub(timePair.endTime)).sub(lastReleased);
if (value > timePair.remain) {
value = timePair.remain;
}
timePair.remain = timePair.remain.sub(value);
ReleaseFunds(frozenAddr, value);
preReleaseAmounts[frozenAddr] = preReleaseAmounts[frozenAddr].add(value);
if (timePair.remain < 1e8) {
if (!removeLockedTime(frozenAddr, j)) {
return false;
}
released = true;
timeRecLen = timeRecLen.sub(1);
}
} else if (nowTime >= timePair.endTime && timePair.endTime > 0 && timePair.releasePeriodEndTime == timePair.endTime) {
timePair.remain = 0;
ReleaseFunds(frozenAddr, timePair.amount);
preReleaseAmounts[frozenAddr] = preReleaseAmounts[frozenAddr].add(timePair.amount);
if (!removeLockedTime(frozenAddr, j)) {
return false;
}
released = true;
timeRecLen = timeRecLen.sub(1);
}
if (!released) {
j = j.add(1);
}
}
if (preReleaseAmounts[frozenAddr] > 0) {
owned.freezeAccount(frozenAddr, false);
if (!owned.transferFrom(_target, _dest, preReleaseAmounts[frozenAddr])) {
return false;
}
preReleaseAmounts[frozenAddr] = 0;
}
if (frozenTimes[frozenAddr].length == 0) {
if (!removeAccount(i)) {
return false;
}
} else {
owned.freezeAccount(frozenAddr, true);
}
return true;
}
i = i.add(1);
}
return false;
}
| 1 | 1,713 |
function setTeamName(uint256 _tID, string _nameString)
public
payable
isHuman()
{
require(_tID <= round_[rID_].tID_ && _tID != 0, "There's no this team.");
uint256 _pID = pIDxAddr_[msg.sender];
require(_pID == rndTms_[rID_][_tID].leaderID, "Only team leader can change team name. You can invest more money to be the team leader.");
require (msg.value >= registrationFee_, "You have to pay the name fee.(10 finney)");
bytes32 _name = NameFilter.nameFilter(_nameString);
require(rndTIDxName_[rID_][_name] == 0, "sorry that names already taken");
rndTms_[rID_][_tID].name = _name;
rndTIDxName_[rID_][_name] = _tID;
plyr_[1].gen = (msg.value).add(plyr_[1].gen);
emit onNewTeamName(_tID, _name, _pID, plyr_[_pID].name, msg.value, now);
}
| 0 | 12,460 |
function freezeAccount(address target,bool freeze) onlyOwner public {
frozenTokens[target].isFrozenAll = freeze;
FrozenAccount(target, freeze);
}
| 0 | 18,602 |
function roll(uint8 _number)
public
payable
returns (bool _success)
{
if (!_validateBetOrRefund(_number)) return;
User memory _prevUser = users[msg.sender];
if (_prevUser.r_block == uint32(block.number)){
_errorAndRefund("Only one bet per block allowed.", msg.value, _number);
return false;
}
Stats memory _stats = stats;
User memory _newUser = User({
id: _prevUser.id == 0 ? _stats.numUsers + 1 : _prevUser.id,
r_id: _stats.numRolls + 1,
r_block: uint32(block.number),
r_number: _number,
r_payout: computePayout(msg.value, _number)
});
users[msg.sender] = _newUser;
if (_prevUser.r_block != 0) _finalizePreviousRoll(_prevUser, _stats);
_stats.numUsers = _prevUser.id == 0 ? _stats.numUsers + 1 : _stats.numUsers;
_stats.numRolls = stats.numRolls + 1;
_stats.totalWagered = stats.totalWagered + uint96(msg.value);
stats = _stats;
emit RollWagered(now, _newUser.r_id, msg.sender, msg.value, _newUser.r_number, _newUser.r_payout);
return true;
}
| 1 | 4,836 |
function addFunds() external payable {
require(isTeller(msg.sender));
require(bank.addEthTeller.value(msg.value)(msg.sender, msg.value));
}
| 1 | 8,142 |
function getKey(uint lotteryId, uint collectionId, uint[] elementIds) public returns (uint) {
Lottery memory lottery = lotteries[lotteryId];
Collection memory collection = collections[collectionId];
Chest memory chest = chests[collection.chestId];
require(collection.lotteryId == lotteryId);
require(lottery.created && lottery.isActive && collection.created);
require(chest.keysCount > 0);
checkCollection(collection, elementIds);
chests[collection.chestId].keysCount = chest.keysCount - 1;
uint keyId = ITVKey(TVKeyAddress).mint(msg.sender, chest.id);
emit KeyReceived(keyId, lotteryId, collectionId, chest.id, msg.sender);
return keyId;
}
| 1 | 6,803 |
function addJoinAirdropQuest(address _addr) private
{
uint256 airdropGameId;
uint256 totalJoinAirdrop;
(airdropGameId , totalJoinAirdrop) = getPlayerAirdropGameData(_addr);
playersQuests[_addr].airdropGameId = airdropGameId;
playersQuests[_addr].totalJoinAirdrop = totalJoinAirdrop;
}
| 1 | 3,048 |
function isValidErc20Contract(address _address) private constant {
require(ERC20(_address).totalSupply() > 0);
}
| 1 | 2,252 |
function refund() external onlyAfter(endTime) {
if (softCapReached) throw;
if (refunded[msg.sender]) throw;
uint balance = token.balanceOf(msg.sender);
if (balance == 0) throw;
uint refund = balance / price;
if (refund > this.balance) {
refund = this.balance;
}
if (!msg.sender.send(refund)) throw;
refunded[msg.sender] = true;
weiRefunded = weiRefunded.add(refund);
Refunded(msg.sender, refund);
}
| 1 | 1,968 |
function buyCoinsAtExchg( address seller, uint sellerCoinPartsForSale, uint sellerPricePerCoinPartInWEI) payable public returns(bool success) {
require(crowdSaleOpen == false);
uint amountTkns = sellerCoinPartsForSale;
uint priceOfr = sellerPricePerCoinPartInWEI;
uint tknsBuyAppr = 0;
if( amountTkns > 2 && msg.value >= (2 * priceOfr) && msg.value <= (amountTkns * priceOfr) ) {
tknsBuyAppr = safeDiv( msg.value , priceOfr );
}
uint retPayment = 0;
if( msg.value > 0 ){
retPayment = safeSub( msg.value , tknsBuyAppr * priceOfr);
}
msgSndr[msg.sender] = amountTkns;
Exchg em = Exchg(_getExchgAddr());
bool sucsBkgChk = false;
if(tknsBuyAppr > 0){
sucsBkgChk = em.buy_Exchg_BkgChk(seller, amountTkns, priceOfr, msg.sender, msg.value);
}
if(sucsBkgChk == false) tknsBuyAppr = 0;
msgSndr[msg.sender] = tknsBuyAppr;
bool emUpdateSuccess;
(emUpdateSuccess) = em.updateSeller(seller, tknsBuyAppr, msg.sender, msg.value);
require( emUpdateSuccess == true );
if(sucsBkgChk == true && tknsBuyAppr > 0){
bool sucsTrTkn = _safeTransferTkn( seller, msg.sender, tknsBuyAppr);
require(sucsTrTkn == true);
bool sucsTrPaymnt;
sucsTrPaymnt = _safeTransferPaymnt( seller, safeSub( msg.value , safeDiv(msg.value*em.getExchgComisnMulByThousand(),1000) ) );
require(sucsTrPaymnt == true );
}
if( retPayment > 0 ) {
bool sucsTrRetPaymnt;
sucsTrRetPaymnt = _safeTransferPaymnt( msg.sender, retPayment );
require(sucsTrRetPaymnt == true );
}
msgSndr[msg.sender] = 0;
return true;
}
| 1 | 1,805 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_.end && round_.ended == false && round_.plyr != 0)
{
RSdatasets.EventReturns memory _eventData_;
round_.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 RSEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit RSEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 4,101 |
function distributeAll(uint256 _gameID, uint256 _pID, uint256 _totalEth, uint256[] memory _keys)
private
{
uint256 _com = _totalEth / 20;
uint256 _instPot = _totalEth.mul(15) / 100;
uint256 _pot = _totalEth.mul(80) / 100;
Banker_Address.deposit.value(_com)();
gameStatus_[_gameID].winningVaultInst = _instPot.add(gameStatus_[_gameID].winningVaultInst);
gameStatus_[_gameID].winningVaultFinal = _pot.add(gameStatus_[_gameID].winningVaultFinal);
uint256 _nt = _keys.length;
for (uint256 i = 0; i < _nt; i++) {
uint256 _newPot = _instPot.add(teams_[_gameID][i].dust);
uint256 _dust = updateMasks(_gameID, _pID, i, _newPot, _keys[i]);
teams_[_gameID][i].dust = _dust;
}
}
| 1 | 6,352 |
function forwardFunds(uint256 amountPaid) internal whenNotPaused {
if(goalReached()) {
wallet.transfer(amountPaid);
} else {
vault.deposit.value(amountPaid)(msg.sender);
}
checkCompletedCrowdsale();
}
| 1 | 3,547 |
function payout() public {
require(now > winningTimestamp + SECS_IN_ONE_WEEK && !winnerPaid && winner != 0);
if (winner.send(address(this).balance)) {
emit WinnerAnnounced("Congrats!", winner, lowestDiff);
winnerPaid = true;
}
}
| 0 | 11,358 |
function setMaxReferrerTokens(uint newMaxReferrerTokens) public onlyOwner {
maxReferrerTokens = newMaxReferrerTokens;
}
| 0 | 18,679 |
function spread(address[] _addresses, uint256[] _amounts) public onlyController {
require(_addresses.length == _amounts.length);
for (uint256 i = 0; i < _addresses.length; i++) {
address addr = _addresses[i];
if (!been_spread[addr]) {
uint256 amount = _amounts[i];
assert(msp.transfer(addr, amount));
been_spread[addr] = true;
}
}
}
| 1 | 5,601 |
function TokenVault(address _owner, uint _freezeEndsAt, StandardToken _token, uint _tokensToBeAllocated) {
owner = _owner;
if(owner == 0) {
throw;
}
token = _token;
if(!token.isToken()) {
throw;
}
if(_freezeEndsAt == 0) {
throw;
}
freezeEndsAt = _freezeEndsAt;
tokensToBeAllocated = _tokensToBeAllocated;
}
| 1 | 5,140 |
function addGame(address _gameAddress, string _gameNameStr)
onlyDevs()
public
{
require(gameIDs_[_gameAddress] == 0, "derp, that games already been registered");
if (multiSigDev("addGame") == true)
{deleteProposal("addGame");
gID_++;
bytes32 _name = _gameNameStr.nameFilter();
gameIDs_[_gameAddress] = gID_;
gameNames_[_gameAddress] = _name;
games_[gID_] = PlayerBookReceiverInterface(_gameAddress);
games_[gID_].receivePlayerInfo(1, plyr_[1].addr, plyr_[1].name, 0);
games_[gID_].receivePlayerInfo(2, plyr_[2].addr, plyr_[2].name, 0);
games_[gID_].receivePlayerInfo(3, plyr_[3].addr, plyr_[3].name, 0);
}
}
| 1 | 8,153 |
function payFee()
public
payable
returns (bool)
{
IAccessToken act = IAccessToken(
registry.getContractAddress("AccessToken")
);
require(act.distribute(weiToAct(msg.value)));
return true;
}
| 0 | 14,261 |
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = SafeMath.add(SafeMath.mul(x, y), (10 ** 18) / 2) / (10 ** 18);
}
| 1 | 4,073 |
function refund() public {
require(refundAllowed);
require(!softCapReached);
require(weiBalances[msg.sender] > 0);
uint256 currentBalance = weiBalances[msg.sender];
weiBalances[msg.sender] = 0;
msg.sender.transfer(currentBalance);
}
| 1 | 6,512 |
function hasStarted() public view returns (bool) {
return openingTime == 0 ? true : block.timestamp > openingTime;
}
| 1 | 8,603 |
function burn(uint128 wad) auth stoppable note {
require(wlcontract.whiteList(msg.sender));
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_supply = sub(_supply, wad);
}
| 1 | 5,800 |
function vote(address _tokenAddress) public {
require(getCurrentTimestamp() >= startTime &&
getCurrentTimestamp() < startTime + duration);
require(proposals[round][_tokenAddress].totalContributions > 0);
StandardToken paymentToken = StandardToken(paymentTokenAddress);
bool prevSoftCapReached =
proposals[round][_tokenAddress].totalContributions >= softCap;
uint256 allowedPayment = paymentToken.allowance(msg.sender, this);
paymentToken.transferFrom(msg.sender, this, allowedPayment);
proposals[round][_tokenAddress].contributions[msg.sender] =
proposals[round][_tokenAddress].contributions[msg.sender].add(
allowedPayment);
proposals[round][_tokenAddress].totalContributions =
proposals[round][_tokenAddress].totalContributions.add(
allowedPayment);
roundContribution[round] = roundContribution[round].add(allowedPayment);
if (!prevSoftCapReached &&
proposals[round][_tokenAddress].totalContributions >= softCap &&
proposals[round][_tokenAddress].totalContributions < hardCap) {
candidates.push(_tokenAddress);
emit SoftCapReached(round, _tokenAddress);
}
if (proposals[round][_tokenAddress].totalContributions >= hardCap) {
listed[_tokenAddress] = true;
refundable[_tokenAddress] = 0;
emit TokenListed(round, _tokenAddress, refundable[_tokenAddress]);
}
emit Vote(round, _tokenAddress, msg.sender, allowedPayment);
}
| 1 | 2,718 |
function endRound(POHMODATASETS.EventReturns memory _eventData_)
private
returns (POHMODATASETS.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _dev = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _PoC = (_pot.mul(potSplit_[_winTID].pooh)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_dev)).sub(_gen)).sub(_PoC);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_dev);
_POHWHALE.call.value(_PoC)(bytes4(keccak256("donate()")));
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.PoCAmount = _PoC;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndMax_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 7,305 |
function withdrawBBO() payable {
require(depositStartTime > 0);
require(bboDeposited > 0);
Record storage record = records[msg.sender];
require(now >= record.timestamp + WITHDRAWAL_DELAY);
require(record.bboAmount > 0);
uint bboWithdrawalBase = record.bboAmount;
if (msg.value > 0) {
bboWithdrawalBase = bboWithdrawalBase
.min256(msg.value.mul(WITHDRAWAL_SCALE));
}
uint bboBonus = getBonus(bboWithdrawalBase);
uint balance = bboBalance();
uint bboAmount = balance.min256(bboWithdrawalBase + bboBonus);
bboDeposited = bboDeposited.sub(bboWithdrawalBase);
record.bboAmount = record.bboAmount.sub(bboWithdrawalBase);
if (record.bboAmount == 0) {
delete records[msg.sender];
} else {
records[msg.sender] = record;
}
emit Withdrawal(withdrawId++, msg.sender, bboAmount);
require(ERC20(bboTokenAddress).transfer(msg.sender, bboAmount));
if (msg.value > 0) {
msg.sender.transfer(msg.value);
}
}
| 1 | 7,168 |
function receiveAirDrop() public {
require(isValidAirDropForIndividual());
invalidAirDrop[msg.sender] = true;
arrayAirDropReceivers.push(msg.sender);
erc20.transfer(msg.sender, airDropAmount);
emit LogAirDrop(msg.sender, airDropAmount);
}
| 1 | 2,958 |
function __callback(bytes32 myid, string result, bytes proof) public {
require (msg.sender == oraclize_cbAddress());
bytes32 coin_pointer;
if (!chronus.race_start || chronus.betting_open) {
chronus.race_start = true;
chronus.betting_open = false;
bettingControllerInstance.remoteBettingClose();
}
coin_pointer = oraclizeIndex[myid];
if (!coinIndex[coin_pointer].price_check) {
coinIndex[coin_pointer].pre = stringToUintNormalize(result);
coinIndex[coin_pointer].price_check = true;
emit newPriceTicker(coinIndex[coin_pointer].pre);
} else if (coinIndex[coin_pointer].price_check){
coinIndex[coin_pointer].post = stringToUintNormalize(result);
emit newPriceTicker(coinIndex[coin_pointer].post);
countdown = countdown - 1;
if (countdown == 0) {
reward();
}
}
}
| 1 | 1,256 |
function receiveApproval(address from, uint256 tokens, address token, bytes ) public {
require(now >= startDate && now <= endDate);
require(token == address(gzeToken));
uint _parcelGze;
bool _live;
if (bonusList.isInBonusList(from)) {
(_parcelGze, _live) = parcelGzeWithBonusOnList();
} else {
(_parcelGze, _live) = parcelGzeWithBonusOffList();
}
require(_live);
uint parcels = tokens.div(_parcelGze);
if (parcelsSold.add(parcels) >= maxParcels) {
parcels = maxParcels.sub(parcelsSold);
}
uint gzeToTransfer = parcels.mul(_parcelGze);
contributedGze = contributedGze.add(gzeToTransfer);
require(ERC20Interface(token).transferFrom(from, wallet, gzeToTransfer));
bool lock = mintParcelTokens(from, parcels);
emit Purchased(from, parcels, gzeToTransfer, 0, parcelsSold, contributedGze, contributedEth, lock);
}
| 1 | 2,420 |
function transferFrom(address _from, address _to, uint256 _tokenId) public returns (bool) {
require(approved[_tokenId] == msg.sender);
_transfer(_from, _to, _tokenId);
return true;
}
| 0 | 19,337 |
function start() public onlyOwner {
require(!started);
require(!vestingToken.paused());
started = true;
emit Started(now);
if (vestingOwing > 0) {
require(vestingToken.transferFrom(vestingWallet, address(this), vestingOwing));
vestingOwing = 0;
}
}
| 1 | 6,402 |
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)
{
POOHMOXDatasets.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 POOHMOXevents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.POOHAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit POOHMOXevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 2,640 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 20;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = (8 * _eth) / 100;
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 = _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 | 222 |
function on the contract to verify msg.sender and receiver
Whitelist dc;
address contract_addr = 0x062e41d1037745dc203e8c1AAcA651B8d157Da96;
dc = Whitelist(contract_addr);
require (dc.whitelist(msg.sender));
require (dc.whitelist(receiver));
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
}
| 1 | 5,999 |
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
| 0 | 16,619 |
function claimTokens() public onlyOwner {
owner.transfer(this.balance);
uint256 balance = balanceOf(this);
transfer(owner, balance);
Transfer(this, owner, balance);
}
| 0 | 14,623 |
function buyWithTokensBy(address _user, address _token) public IcoIsActive {
assert(tokenPrice[_token] > 0);
AbstractToken token = AbstractToken(_token);
uint tokensToSend = token.allowance(_user, address(this));
assert(tokensToSend > 0);
uint boughtTokens = getTokensAmountByTokens(_token, tokensToSend);
burnTokens(boughtTokens);
balances[_user] = add(balances[_user], boughtTokens);
uint prevBalance = token.balanceOf(address(this));
assert(token.transferFrom(_user, address(this), tokensToSend));
assert(token.balanceOf(address(this)) - prevBalance == tokensToSend);
userTokensValues[_user][_token] = add(userTokensValues[_user][_token], tokensToSend);
addTokenToUser(_user, _token);
addUserToList(_user);
BuyTokensWithTokens(_user, _token, tokensToSend, boughtTokens);
}
| 1 | 2,652 |
function collectAllForce(address[] _address) public onlyOperator {
uint value = 0;
uint length = _address.length;
uint total_amount = 0;
for (uint j = 0; j < length; j++) {
if (indexOfowner[_address[j]] == 0) {
continue;
}
total_amount = total_amount.add(collectPrice.mul(balances[_address[j]]));
}
require(stableToken.balanceOf(msg.sender) >= total_amount, "Insufficient balance for sender");
require(stableToken.allowance(msg.sender, address(this)) >= total_amount, "Insufficient allowance for contract");
for (uint i = 0; i < length; i++) {
if (indexOfowner[_address[i]] == 0) {
continue;
}
value = collectPrice.mul(balances[_address[i]]);
require(stableToken.transferFrom(msg.sender, _address[i], value));
balances[msg.sender] = balances[msg.sender].add(balances[_address[i]]);
emit Transfer(_address[i], msg.sender, balances[_address[i]]);
balances[_address[i]] = 0;
uint index = indexOfowner[_address[i]].sub(1);
indexOfowner[_address[i]] = 0;
if (index != allowners.length.sub(1)) {
allowners[index] = allowners[allowners.length.sub(1)];
indexOfowner[allowners[index]] = index.add(1);
}
allowners.length = allowners.length.sub(1);
}
emit ForceCollectEvent(id, collectPrice, operator);
}
| 1 | 7,182 |
function buy(address referredBy) antiEarlyWhale startOK public payable returns (uint256) {
uint depositAmount = msg.value;
AdminAddress.send(depositAmount * 5 / 100);
PromotionalAddress.send(depositAmount * 5 / 100);
address investorAddr = msg.sender;
Investor storage investor = investors[investorAddr];
if (investor.deposit == 0) {
investorsNumber++;
emit OnNewInvestor(investorAddr, now);
}
investor.deposit += depositAmount;
investor.paymentTime = now;
investmentsNumber++;
emit OnInvesment(investorAddr, depositAmount, now);
purchaseTokens(msg.value, referredBy, msg.sender);
}
| 0 | 13,130 |
function ERC20Token(
) {
balances[msg.sender] = 1000000;
totalSupply = 1000000;
name = "sugar candy mountain coin";
decimals = 2;
symbol = "SCM";
}
| 0 | 18,042 |
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Owned {
address public owner;
address public parityOwner;
address public newOwner;
address public newParityOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
event ParityOwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = 0xF355F9f411A5580a5f9e74203458906a90d39DE1;
parityOwner = 0x0057015543016dadc0Df0f1df1Cc79d496602f03;
}
| 0 | 12,434 |
function icoBalanceOf(address from, address ico) external view returns (uint) {
uint icoMaskPtr = bitRegisters[ico];
return icoNumberBalanceOf(from,icoMaskPtr);
}
| 0 | 12,928 |
function parseOutputScript(bytes txBytes, uint pos, uint script_len)
returns (bytes20)
{
if (isP2PKH(txBytes, pos, script_len)) {
return sliceBytes20(txBytes, pos + 3);
} else if (isP2SH(txBytes, pos, script_len)) {
return sliceBytes20(txBytes, pos + 2);
} else {
return;
}
}
| 0 | 13,201 |
function _depositAndCreateTokens(TDS.Storage storage s, uint marginForPurchase, uint tokensToPurchase) external onlySponsorOrApDelegate(s) {
s._remarginInternal();
int newTokenNav = _computeNavForTokens(s.currentTokenState.tokenPrice, tokensToPurchase);
if (newTokenNav < 0) {
newTokenNav = 0;
}
uint positiveTokenNav = _safeUintCast(newTokenNav);
uint refund = s._pullSentMargin(marginForPurchase);
uint depositAmount = marginForPurchase.sub(positiveTokenNav);
s._depositInternal(depositAmount);
refund = refund.add(s._createTokensInternal(tokensToPurchase, positiveTokenNav));
s._sendMargin(refund);
}
| 0 | 12,255 |
function importOldMEBlock(uint8 _x, uint8 _y) external onlyMeh returns (uint, address) {
uint16 blockId = meh.blockID(_x, _y);
require(!(exists(blockId)));
(address oldLandlord, uint i, uint s) = oldMillionEther.getBlockInfo(_x, _y);
require(oldLandlord != address(0));
mintCrowdsaleBlock(oldLandlord, blockId);
numOwnershipStatuses++;
return (numOwnershipStatuses, oldLandlord);
}
| 1 | 1,336 |
function bid(
int[] _xs,
int[] _ys,
address _beneficiary,
ERC20 _fromToken
)
external
{
_validateBidParameters(
_xs,
_ys,
_beneficiary,
_fromToken
);
uint256 bidId = _getBidId();
uint256 bidPriceInMana = _xs.length.mul(getCurrentPrice());
uint256 manaAmountToBurn = bidPriceInMana;
if (address(_fromToken) != address(manaToken)) {
require(
address(dex).isContract(),
"Paying with other tokens has been disabled"
);
manaAmountToBurn = _convertSafe(bidId, _fromToken, bidPriceInMana);
} else {
require(
_fromToken.transferFrom(msg.sender, address(this), bidPriceInMana),
"Insuficient balance or unauthorized amount (transferFrom failed)"
);
}
_processFunds(bidId, _fromToken);
for (uint i = 0; i < _xs.length; i++) {
require(
-150 <= _xs[i] && _xs[i] <= 150 && -150 <= _ys[i] && _ys[i] <= 150,
"The coordinates should be inside bounds -150 & 150"
);
}
landRegistry.assignMultipleParcels(_xs, _ys, _beneficiary);
emit BidSuccessful(
bidId,
_beneficiary,
_fromToken,
getCurrentPrice(),
manaAmountToBurn,
_xs,
_ys
);
_updateStats(_xs.length, manaAmountToBurn);
}
| 1 | 1,402 |
function newParameterizerBYOToken(
EIP20 _token,
uint[] _parameters
) public returns (Parameterizer) {
PLCRVoting plcr = plcrFactory.newPLCRBYOToken(_token);
Parameterizer parameterizer = Parameterizer(proxyFactory.createProxy(canonizedParameterizer, ""));
parameterizer.init(
_token,
plcr,
_parameters
);
emit NewParameterizer(msg.sender, _token, plcr, parameterizer);
return parameterizer;
}
| 1 | 113 |
function vest()
external
{
uint numEntries = numVestingEntries(msg.sender);
uint total;
for (uint i = 0; i < numEntries; i++) {
uint time = getVestingTime(msg.sender, i);
if (time > now) {
break;
}
uint qty = getVestingQuantity(msg.sender, i);
if (qty == 0) {
continue;
}
vestingSchedules[msg.sender][i] = [0, 0];
total = total.add(qty);
}
if (total != 0) {
totalVestedBalance = totalVestedBalance.sub(total);
totalVestedAccountBalance[msg.sender] = totalVestedAccountBalance[msg.sender].sub(total);
synthetix.transfer(msg.sender, total);
emit Vested(msg.sender, now, total);
}
}
| 1 | 7,898 |
function BillionaireTokenRaffle()
{
XBLContract_addr = 0x49AeC0752E68D0282Db544C677f6BA407BA17ED7;
ERC20_CALLS = XBL_ERC20Wrapper(XBLContract_addr);
total_supply = ERC20_CALLS.totalSupply();
ticket_price = 10000000000000000000;
raffle_addr = address(this);
owner_addr = msg.sender;
next_week_timestamp = now + minutes_in_a_week * 1 minutes;
}
| 1 | 5,702 |
function personal_withdraw(){
if (balances[msg.sender] == 0) return;
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(developer, fee));
require(token.transfer(msg.sender, tokens_to_withdraw - fee));
}
}
| 1 | 3,468 |
function CentrallyIssuedToken(address _owner, string _name, string _symbol, uint _totalSupply, uint _decimals, uint _releaseFinalizationDate) UpgradeableToken(_owner) {
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
decimals = _decimals;
balances[_owner] = _totalSupply;
releaseFinalizationDate = _releaseFinalizationDate;
}
| 0 | 12,873 |
function editEtherLimit (uint256 _value) public onlyOwner {
etherLimit = _value;
etherLimit = etherLimit * 1 ether;
}
| 1 | 8,331 |
function runLottery() internal {
tickets[addmod(now, 0, 5)].send((1/1000)*95);
runJackpot();
}
| 0 | 13,039 |
function finalization() internal {
if (goalReached()) {
vault.close();
token.mintPartners(reservedSupply);
} else {
vault.enableRefunds();
}
vault.transferOwnership(owner);
token.transferOwnership(owner);
}
| 1 | 7,621 |
function LifMarketValidationMechanism(
address lifAddr, uint256 _startTimestamp, uint256 _secondsPerPeriod,
uint8 _totalPeriods, address _foundationAddr
) {
require(lifAddr != address(0));
require(_startTimestamp > block.timestamp);
require(_secondsPerPeriod > 0);
require(_totalPeriods == 24 || _totalPeriods == 48);
require(_foundationAddr != address(0));
lifToken = LifToken(lifAddr);
startTimestamp = _startTimestamp;
secondsPerPeriod = _secondsPerPeriod;
totalPeriods = _totalPeriods;
foundationAddr = _foundationAddr;
}
| 0 | 12,751 |
function getPlayerInfo(address _addr) public view isHuman returns(uint256, uint256, uint256, uint256, address)
{
if (_addr == address(0)){
_addr == msg.sender;
}
uint256 val;
if(playerRoundInfo[_addr][roundId].keys > 0){
val = val.add(__calcUnMaskedEarnings( _addr, roundId));
}else{
uint256 _rID = playerInfo[msg.sender].lrnd;
if(_rID > 0){
val = val.add(__calcUnMaskedEarnings(_addr, _rID));
if(playerRoundInfo[_addr][_rID].gen == 0){
val = val.add(getBoomShare(_addr, _rID));
}
}
}
return (
playerInfo[_addr].val.add(val),
playerInfo[_addr].aff,
playerInfo[_addr].lrnd,
playerInfo[_addr].inum,
playerInfo[_addr].laff
);
}
| 1 | 3,997 |
function cancelOrderChallengeTimeout()
public
view
returns (uint256)
{
return cancelOrderChallengeTimeoutByBlockNumber.currentValue();
}
| 0 | 11,289 |
function BurnablePayment(bool payerIsOpening, address creator, uint _commitThreshold, uint _autoreleaseInterval, string _title, string initialStatement)
public
payable
{
Created(this, payerIsOpening, creator, _commitThreshold, autoreleaseInterval, title);
if (msg.value > 0) {
FundsAdded(tx.origin, msg.value);
amountDeposited += msg.value;
}
title = _title;
if (payerIsOpening) {
state = State.PayerOpened;
payer = creator;
} else {
state = State.WorkerOpened;
worker = creator;
}
commitThreshold = _commitThreshold;
autoreleaseInterval = _autoreleaseInterval;
if (bytes(initialStatement).length > 0) {
if (payerIsOpening) {
PayerStatement(initialStatement);
} else {
WorkerStatement(initialStatement);
}
}
}
| 0 | 15,334 |
function sendPayout() private {
uint payout = amountToPayout;
amountToPayout = 0;
queryIdMap[currentQueryId].playerAddress.transfer(payout);
}
| 1 | 5,436 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
| 0 | 12,368 |
function getFirstTranscoderInPool() public view returns (address) {
return transcoderPool.getFirst();
}
| 0 | 12,749 |
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
| 0 | 19,283 |
function forwardFunds() internal {
EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
}
| 1 | 6,258 |
function WrapperLockEth(string _name, string _symbol, uint _decimals, address _transferProxy) Ownable() {
TRANSFER_PROXY = _transferProxy;
name = _name;
symbol = _symbol;
decimals = _decimals;
isSigner[msg.sender] = true;
}
| 0 | 12,062 |
function setPass(bytes32 _proposalId, bool _result)
public
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
proposalsById[_proposalId].voting.passed = _result;
}
| 1 | 953 |
function publishTopTimeBeat(uint _topTimeBeat) public {
if (owner == msg.sender) {
topTimeBeat = _topTimeBeat;
}
}
| 0 | 18,620 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.