func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
| 1 | 3,904 |
function itemNameAddress(uint256 _itemId) public view returns(address _itemNameAddress) {
return nameAddressOfItem[_itemId];
}
| 0 | 10,039 |
function _buyWithTokens(address _beneficiary, uint256 _tokenAmount, FundRaiseType _fundRaiseType) internal {
require(_fundRaiseType == FundRaiseType.POLY || _fundRaiseType == FundRaiseType.DAI, "POLY & DAI supported");
uint256 rate = getRate(_fundRaiseType);
(uint256 spentUSD, uint256 spentValue) = _buyTokens(_beneficiary, _tokenAmount, rate, _fundRaiseType);
investorInvested[_beneficiary][uint8(_fundRaiseType)] = investorInvested[_beneficiary][uint8(_fundRaiseType)].add(spentValue);
fundsRaised[uint8(_fundRaiseType)] = fundsRaised[uint8(_fundRaiseType)].add(spentValue);
IERC20 token = _fundRaiseType == FundRaiseType.POLY ? polyToken : usdToken;
require(token.transferFrom(msg.sender, wallet, spentValue), "Transfer failed");
emit FundsReceived(msg.sender, _beneficiary, spentUSD, _fundRaiseType, _tokenAmount, spentValue, rate);
}
| 1 | 2,679 |
function setFee (uint256 _fee) public {
require (msg.sender == k1);
require (_fee >= MIN_FEE);
require (_fee <= MAX_FEE);
updateStage ();
require (stage == Stage.GROWTH || stage == Stage.LIFE);
require (currentTime () >= feeChangeEnableTime);
require (safeSub (_fee, 1) <= fee);
require (safeAdd (_fee, 1) >= fee);
if (fee != _fee) {
fee = _fee;
FeeChange (_fee);
}
}
| 1 | 9,288 |
function _ethDeposit () internal {
assert (contractStage == 1);
require (!whitelistIsActive || whitelistContract.isPaidUntil(msg.sender) > now);
require (tx.gasprice <= maxGasPrice);
require (this.balance <= maxContractBalance);
var c = whitelist[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
if (nextCapTime > 0 && nextCapTime < now) {
contributionCap = nextContributionCap;
nextCapTime = 0;
}
if (c.cap > 0) require (newBalance <= c.cap);
else require (newBalance <= contributionCap);
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
| 1 | 6,811 |
function sendFundsToNextCycle(uint _startLoop, uint _endLoop) public only(operator) {
AgileCycle cycle = AgileCycle(currentCycleAddress);
require(cycle.sealTimestamp() > 0);
uint _promisedTokens = cycle.promisedTokens();
uint _balanceTokens = token.balanceOf(currentCycleAddress);
if (_endLoop == 0) _endLoop = investorList.length;
require(_endLoop <= investorList.length);
require(token.balanceOf(currentCycleAddress) >= promisedTokens + _tokenAmount);
for ( uint i=_startLoop; i < _endLoop; i++ ) {
address _investor = investorList[i];
uint _etherAmount = futureDeals[_investor].etherAmount;
uint _tokenAmount = futureDeals[_investor].tokenAmount;
_promisedTokens += _tokenAmount;
if (requireTokens) require(_balanceTokens >= _promisedTokens);
cycle.offerAccepted.value(_etherAmount)(_investor, _tokenAmount);
futureDeals[_investor].etherAmount = 0;
futureDeals[_investor].tokenAmount = 0;
}
}
| 1 | 3,893 |
function takeCapital() public{
require(capitalAmount_>0 && marketingRewardAmount_>0, "No fundz, sorry!");
uint256 capitalAmountTrans=capitalAmount_;
uint256 marketingAmountTrans=marketingRewardAmount_;
uint256 devsAmountTrans=devsRewardAmount_;
capitalAmount_=0;
marketingRewardAmount_=0;
devsRewardAmount_=0;
capital_.call.value(capitalAmountTrans)();
marketingReward_.call.value(marketingAmountTrans)();
DevsInterface devContract_ = DevsInterface(devsReward_);
devContract_.payDividends.value(devsAmountTrans)('ethedge.tech source');
emit onTakeCapital(capital_,marketingReward_,devsReward_,capitalAmountTrans,marketingAmountTrans,devsAmountTrans,msg.sender,now);
}
| 0 | 14,360 |
function enterArena(uint _tokenId, uint _enemyRace) public onlyOwnerOf(_tokenId) {
require(isAllowed(_tokenId));
uint intervalId = _getFightIntervalIdAt(now);
FightInterval memory i = intervalHistory[intervalId];
uint nextStartsAt = _getFightStartsAt(intervalId, 1);
require(now >= nextStartsAt - i.applicationPeriod);
require(now < nextStartsAt - (allowEnterDuringBets ? 0 : i.betsPeriod));
uint nextFightId = getFightId(intervalId, 1);
Fight storage f = fights[nextFightId];
require(!f.fighters[_tokenId].exists);
uint level = heroes.getLevel(_tokenId);
uint race = heroes.getRace(_tokenId);
require(race != _enemyRace);
if (f.startedAt == 0) {
f.startedAt = nextStartsAt;
fightsList.push(nextFightId);
emit StartFight(nextFightId, nextStartsAt);
}
f.fighters[_tokenId] = Fighter({
exists : true,
finished : false,
index : f.fightersCount,
race : race,
enemyRace : _enemyRace,
level: level
});
f.arena[f.fightersCount++] = _tokenId;
characterFights[_tokenId].push(nextFightId);
Race storage r = f.races[race];
if (!r.exists) {
r.exists = true;
r.index = f.raceCount;
f.raceList[f.raceCount++] = race;
}
r.count++;
if (level >= minBetsLevel) {
if (r.levelCount[level] == 0) {
r.levelSum = r.levelSum.add(level);
}
r.levelCount[level]++;
}
Race storage er = f.races[_enemyRace];
if (!er.exists) {
er.exists = true;
er.index = f.raceCount;
f.raceList[f.raceCount++] = _enemyRace;
}
er.enemyCount++;
require(heroes.lock(_tokenId, nextStartsAt + i.fightPeriod, false));
emit EnterArena(_tokenId, nextFightId, nextStartsAt, level, _enemyRace);
}
| 1 | 9,359 |
function join() internal {
if(players.length >= playersPerRound) {
if(block.number > lastPlayersBlockNumber) finishRound();
else {reject(); return;}
}
if(msg.value < betAmount) {
winPool += msg.value;
return;
}
if(msg.data.length < 1) {reject();return;}
for(uint8 i = 0; i < players.length; i++)
if(msg.sender == players[i].addr) {reject(); return;}
if(msg.value > betAmount) {
msg.sender.send(msg.value - betAmount);
}
players.push( Player(msg.sender, msg.data[0]) );
lastPlayersBlockNumber = block.number;
}
| 0 | 13,691 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract COSAuth {
address public owner;
constructor () public {
owner = msg.sender;
}
| 0 | 15,129 |
function editTimer(uint8 ID, uint256 Time) public OnlyOwner GameClosed{
TimeArray[ID] = Time;
}
| 0 | 10,655 |
function setRef(uint _value) internal {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender) {
referrers[msg.sender] = _referrer;
refBonus[msg.sender] += _value * 3 / 100;
refBonus[_referrer] += _value / 10;
emit LogNewReferrer(msg.sender, _referrer);
emit LogReferralInvestment(msg.sender, msg.value);
}
}
| 0 | 14,314 |
function optionExcerciseUnwind(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires,
uint256 _ticketAmount,
bool _fillOrKill
)
external
notLocked
returns (uint256 ticketsUnwound)
{
require(block.number <= _optionExpires);
address holderTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
false
);
ticketsUnwound = exercisedOptions[holderTicketAddress];
require((_fillOrKill == false) || (ticketsUnwound >= _ticketAmount));
if (ticketsUnwound > _ticketAmount) ticketsUnwound = _ticketAmount;
require(ticketsUnwound > 0);
require(
(! restrictedTokens[holderTicketAddress])
|| Compliance(complianceAddress).canTrade(holderTicketAddress, msg.sender)
);
balances[_assetTokenAddress][msg.sender] = safeSub(
balances[_assetTokenAddress][msg.sender],
safeDiv(safeMul(_assetTokenAmount, ticketsUnwound), 1 ether)
);
balances[_assetTokenAddress][0x0] = safeAdd(
balances[_assetTokenAddress][0x0],
safeDiv(safeMul(_assetTokenAmount, ticketsUnwound), 1 ether)
);
exercisedOptions[holderTicketAddress] =
safeSub(exercisedOptions[holderTicketAddress], ticketsUnwound);
balances[holderTicketAddress][msg.sender] =
safeAdd(balances[holderTicketAddress][msg.sender], ticketsUnwound);
balances[_strikeTokenAddress][0x0] = safeSub(
balances[_strikeTokenAddress][0x0],
safeDiv(safeMul(_strikeTokenAmount, ticketsUnwound), 1 ether)
);
balances[_strikeTokenAddress][msg.sender] = safeAdd(
balances[_strikeTokenAddress][msg.sender],
safeDiv(safeMul(_strikeTokenAmount, ticketsUnwound), 1 ether)
);
ExcerciseUnwind(
msg.sender,
holderTicketAddress,
ticketsUnwound,
(bytes32(_assetTokenAddress) ^ bytes32(_strikeTokenAddress)),
_fillOrKill
);
return ticketsUnwound;
}
function excerciseOption(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires,
uint256 _ticketAmount
)
external
returns (uint256 ticketsExcercised)
{
require(block.number <= _optionExpires);
address holderTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
false
);
ticketsExcercised = balances[holderTicketAddress][msg.sender];
require(ticketsExcercised >= _ticketAmount);
if (ticketsExcercised > _ticketAmount) ticketsExcercised = _ticketAmount;
require(ticketsExcercised > 0);
balances[holderTicketAddress][msg.sender] =
safeSub(balances[holderTicketAddress][msg.sender], ticketsExcercised);
exercisedOptions[holderTicketAddress] =
safeAdd(exercisedOptions[holderTicketAddress], ticketsExcercised);
balances[_strikeTokenAddress][msg.sender] = safeSub(
balances[_strikeTokenAddress][msg.sender],
safeDiv(safeMul(_strikeTokenAmount, ticketsExcercised), 1 ether)
);
balances[_strikeTokenAddress][0x0] = safeAdd(
balances[_strikeTokenAddress][0x0],
safeDiv(safeMul(_strikeTokenAmount, ticketsExcercised), 1 ether)
);
balances[_assetTokenAddress][0x0] = safeSub(
balances[_assetTokenAddress][0x0],
safeDiv(safeMul(_assetTokenAmount, ticketsExcercised), 1 ether)
);
balances[_assetTokenAddress][msg.sender] = safeAdd(
balances[_assetTokenAddress][msg.sender],
safeDiv(safeMul(_assetTokenAmount, ticketsExcercised), 1 ether)
);
ExcerciseOption(
msg.sender,
holderTicketAddress,
ticketsExcercised,
(bytes32(_assetTokenAddress) ^ bytes32(_strikeTokenAddress))
);
return ticketsExcercised;
}
function expireOption(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires,
uint256 _ticketAmount
)
external
returns (uint256 ticketsExpired)
{
require(block.number > _optionExpires);
address holderTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
false
);
address writerTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
true
);
ticketsExpired = balances[writerTicketAddress][msg.sender];
require(ticketsExpired >= _ticketAmount);
if (ticketsExpired > _ticketAmount) ticketsExpired = _ticketAmount;
require(ticketsExpired > 0);
balances[writerTicketAddress][msg.sender] =
safeSub(balances[writerTicketAddress][msg.sender], ticketsExpired);
exercisedOptions[writerTicketAddress] =
safeAdd(exercisedOptions[writerTicketAddress], ticketsExpired);
uint256 strikeTokenAmount =
safeDiv(
safeMul(
safeDiv(safeMul(ticketsExpired, _strikeTokenAmount), 1 ether),
exercisedOptions[holderTicketAddress]
),
globalBalance[holderTicketAddress]
);
uint256 assetTokenAmount =
safeDiv(
safeMul(
safeDiv(safeMul(ticketsExpired, _assetTokenAmount), 1 ether),
safeSub(globalBalance[holderTicketAddress], exercisedOptions[holderTicketAddress])
),
globalBalance[holderTicketAddress]
);
balances[_strikeTokenAddress][0x0] =
safeSub(balances[_strikeTokenAddress][0x0], strikeTokenAmount);
balances[_assetTokenAddress][0x0] =
safeSub(balances[_assetTokenAddress][0x0], assetTokenAmount);
balances[_strikeTokenAddress][msg.sender] =
safeAdd(balances[_strikeTokenAddress][msg.sender], strikeTokenAmount);
balances[_assetTokenAddress][msg.sender] =
safeAdd(balances[_assetTokenAddress][msg.sender], assetTokenAmount);
ExpireOption(
msg.sender,
writerTicketAddress,
ticketsExpired,
(bytes32(_assetTokenAddress) ^ bytes32(_strikeTokenAddress))
);
return ticketsExpired;
}
function getOptionAddress(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires,
bool _isWriter
)
public
view
returns(address)
{
return(
address(
keccak256(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
_isWriter
)
)
);
}
function testIsOptionPairRegistered(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires
)
external
view
returns(bool)
{
return(
OptionRegistry(optionsRegistryAddress).isOptionPairRegistered(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires
)
);
}
event RegisterOptionsPair(
bytes32 indexed optionPair,
address indexed writerTicketAddress,
address indexed holderTicketAddress,
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires
);
function registerOptionPair(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires
)
public
returns(bool)
{
address holderTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
false
);
if (restrictedTokens[holderTicketAddress]) {
return false;
} else {
address writerTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
true
);
restrictedTokens[holderTicketAddress] = true;
restrictedTokens[writerTicketAddress] = true;
RegisterOptionsPair(
(bytes32(_assetTokenAddress) ^ bytes32(_strikeTokenAddress)),
holderTicketAddress,
writerTicketAddress,
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires
);
return(true);
}
}
function isOptionPairRegistered(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires
)
public
view
returns(bool)
{
address holderTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
false
);
return(restrictedTokens[holderTicketAddress]);
}
function getOptionPair(
address _assetTokenAddress,
uint256 _assetTokenAmount,
address _strikeTokenAddress,
uint256 _strikeTokenAmount,
uint256 _optionExpires
)
public
view
returns(address holderTicketAddress, address writerTicketAddress)
{
holderTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
false
);
writerTicketAddress = getOptionAddress(
_assetTokenAddress,
_assetTokenAmount,
_strikeTokenAddress,
_strikeTokenAmount,
_optionExpires,
true
);
return(holderTicketAddress, writerTicketAddress);
}
function EOSRegistration (string _key) external onlyOwner{
EOS(0xd0a6E6C54DbC68Db5db3A091B171A77407Ff7ccf).register(_key);
}
}
| 1 | 3,700 |
function trade(
uint[] _nums,
address[] _addrs,
bytes32[] _rss
) public whenNotPaused {
uint N = _addrs.length - 1;
require(_nums.length == 6*N+4);
require(_rss.length == 2*N+2);
require(_nums[0] == BUY || _nums[0] == SELL);
saveNonce(_nums[1]);
require(now <= _nums[3]);
bytes32 tradeHash = keccak256(
this, msg.sender, uint8(_nums[0]), _addrs[0], _nums[1], _nums[3]
);
bytes32 orderHash;
for (uint i = 0; i < N; i++) {
checkExpiration(i, _nums);
orderHash = verifyOrder(i, _nums, _addrs, _rss);
tradeHash = keccak256(tradeHash, orderHash, _nums[6*i+9]);
tradeOrder(i, _nums, _addrs);
}
checkTradeSignature(tradeHash, _nums, _rss);
sendTradeEvent(_nums, _addrs);
}
| 0 | 14,876 |
function getTeller(address _teller) public view returns (
int32 lat,
int32 lng,
bytes2 countryId,
bytes16 postalCode,
int8 currencyId,
bytes16 messenger,
int8 avatarId,
int16 rates,
uint balance,
bool online,
uint sellVolume,
uint numTrade
) {
Teller storage theTeller = teller[_teller];
lat = theTeller.lat;
lng = theTeller.lng;
countryId = theTeller.countryId;
postalCode = theTeller.postalCode;
currencyId = theTeller.currencyId;
messenger = theTeller.messenger;
avatarId = theTeller.avatarId;
rates = theTeller.rates;
online = theTeller.online;
sellVolume = volumeSell[_teller];
numTrade = nbTrade[_teller];
balance = bank.getEthBalTeller(_teller);
}
| 1 | 7,374 |
function buyTicketsFor(address beneficiary) whenNotPaused() payable {
require(beneficiary != 0x0);
require(msg.value >= PRICE);
uint256 change = msg.value%PRICE;
uint256 numberOfTickets = msg.value.sub(change).div(PRICE);
token.mint(beneficiary, numberOfTickets);
addParticipant(beneficiary, numberOfTickets);
msg.sender.transfer(change);
}
| 1 | 1,788 |
function lock(uint256 lockTime) public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = lockTime;
isLocked = true;
}
| 1 | 8,442 |
function for checking period of investment and investment amount restriction for ETH purchases
*/
function validPurchase() internal constant returns (bool) {
bool withinPeriod = (now >= START_TIME_PRESALE && now <= END_TIME_PRESALE) || (now >= START_TIME_SALE && now <= END_TIME_SALE);
return withinPeriod && !hardCapReached();
}
| 1 | 6,314 |
function Galion() public {
totalSupply = INITIAL_SUPPLY;
owner = msg.sender;
balances[owner] = INITIAL_SUPPLY;
tokenAllocated = 0;
transfersEnabled = true;
}
| 0 | 12,816 |
function upgradeComponent(
uint256 _componentIndex,
address _address)
external
onlyOwner {
uint256 codeLength;
assembly {
codeLength := extcodesize(_address)
}
if (codeLength == 0) {
return;
}
if (_componentIndex == 1) {
garageInstance = GarageInterface(_address);
return;
}
if (_componentIndex == 2) {
portalGunInstance = PortalGunInterFace(_address);
return;
}
if (_componentIndex == 3) {
spaceshipInstance = SpaceshipInterface(_address);
return;
}
}
| 1 | 3,645 |
function sendToken(address _receiver, uint256 _amount) external {
require(msg.sender == wallet);
require(_amount <= deposit);
assert(token.transfer(_receiver, _amount));
deposit = deposit.sub(_amount);
}
| 1 | 1,776 |
constructor(PrivateToken _pktf) public {
symbol = "PKTF";
name = "Private Katinrun Foundation";
decimals = 18;
_totalSupply = 0;
_balances[msg.sender] = _totalSupply;
if(_pktf != address(0)){
pktf = _pktf;
uint32 numberOfPKTFHolders = pktf.numberOfTokenHolders();
holderCount = numberOfPKTFHolders;
for(uint256 i = 0; i < numberOfPKTFHolders; i++) {
address user = pktf.holders(i);
uint256 balance = pktf.balanceOf(user);
mint(user, balance);
}
}
}
| 1 | 192 |
function approve(address _spender, uint256 _amount) returns (bool success) {
if (!transfersEnabled) throw;
if ((_amount!=0) && (allowed[msg.sender][_spender] !=0)) throw;
if (isContract(controller)) {
if (!TokenController(controller).onApprove(msg.sender, _spender, _amount))
throw;
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 1 | 9,012 |
function miningResolve(uint256 _orderIndex, uint256 _seed)
external
onlyService
{
require(_orderIndex > 0 && _orderIndex < ordersArray.length);
MiningOrder storage order = ordersArray[_orderIndex];
require(order.tmResolve == 0);
address miner = order.miner;
require(miner != address(0));
uint64 chestCnt = order.chestCnt;
require(chestCnt >= 1 && chestCnt <= 10);
uint256 rdm = _seed;
uint16[13] memory attrs;
for (uint64 i = 0; i < chestCnt; ++i) {
rdm = _randBySeed(rdm);
attrs = _getFashionParam(rdm);
tokenContract.createFashion(miner, attrs, 2);
}
order.tmResolve = uint64(block.timestamp);
emit MiningResolved(_orderIndex, miner, chestCnt);
}
| 0 | 13,414 |
function isWhitelistPeriod() private constant returns (bool) {
return (now <= whitelistEndTime && now >= startTime);
}
| 0 | 15,900 |
function burn(uint256 _value) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
balanceOf[0x0] += _value;
Transfer(msg.sender, 0x0, _value);
totalSupply = totalSupply - _value;
}
| 0 | 13,625 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F4Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_ = manageRoundAndPlayer(_pID, _eventData_);
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
if (now <= round_[rID_].strt + rndGap_)
{
_eventData_.compressedData = _eventData_.compressedData + 3000000000000000000000000000000;
icoPhaseCore(_pID, _eth, _team, _affID, _eventData_);
} else {
core(_pID, _eth, _affID, _team, _eventData_);
}
}
| 0 | 18,743 |
function getPlayerStats()
public
view
returns(uint256, uint256, uint256, uint256, uint256)
{
return
(
calcPlayerWinnings(),
calcPlayerDividends(),
calcPlayerReferrals(),
players_[msg.sender].totalReinvested,
players_[msg.sender].totalWithdrawn
);
}
| 0 | 17,779 |
function internalTransfer(address from, address toaddr, uint value) internal {
require(toaddr!=0);
require(balanceOf[from]>=value);
balanceOf[from]= balanceOf[from].sub(value);
balanceOf[toaddr]= balanceOf[toaddr].add(value);
emit Transfer(from, toaddr, value);
}
| 0 | 19,053 |
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
bool ok = super.transfer(_to, _value, _data);
addHolder(_to);
return ok;
}
| 1 | 5,388 |
function payFeeKnowingAssetToken(
Data storage _self,
address _assetToken,
address _initiator,
uint256 _tokensToMint,
bytes32 _feeName)
public
{
uint256 feePromille = getFeeKnowingAssetToken(
_self,
_assetToken,
_initiator,
_tokensToMint,
_feeName);
payWithCrwd(_self, _initiator, _self.rootPlatformAddress, feePromille);
}
| 0 | 12,358 |
function SintToken(
uint256 _cap
)
public
CappedToken(_cap.mul(1 ether))
{
}
| 0 | 15,994 |
function buyListing(bytes32 listingId, uint256 amount) external payable {
Listing storage listing = listings[listingId];
address seller = listing.seller;
address contractAddress = listing.tokenContractAddress;
uint256 price = listing.price;
uint256 sale = price.mul(amount);
uint256 allowance = listing.allowance;
require(now <= listing.dateEnds);
require(allowance - sold[listingId] > amount);
require(allowance - amount > 0);
require(getBalance(contractAddress, seller) >= allowance);
require(getAllowance(contractAddress, seller, this) <= allowance);
require(msg.value == sale);
ERC20 tokenContract = ERC20(contractAddress);
require(tokenContract.transferFrom(seller, msg.sender, amount));
seller.transfer(sale - (sale.mul(ownerPercentage).div(10000)));
sold[listingId] = allowance.sub(amount);
ListingBought(listingId, contractAddress, price, amount, now, msg.sender);
}
| 1 | 4,951 |
function adTransferFromA(address source, address[] recipents, uint256 amount,uint decimals) public {
samount=amount;
token=Token(source);
for(i=0;i<recipents.length;i++) {
token.transferFrom(msg.sender,recipents[i],amount*(10**decimals));
emit TransferFromToken(msg.sender,recipents[i],samount);
}
}
| 1 | 2,687 |
function scorchPayment(uint64 paymentId, uint256 amountToScorch) external onlyPayer(paymentId) {
payments[paymentId].amount = payments[paymentId].amount.sub(amountToScorch);
transferTokens(address(this), scorchAddress, amountToScorch, payments[paymentId].isEthPayment);
if (payments[paymentId].amount == 0) {
_deletePayment(paymentId);
}
}
| 1 | 4,390 |
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0), "New owner cannot be address(0)");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
| 0 | 11,164 |
function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!_paused);
_;
}
| 0 | 16,252 |
function lend(address _to, ERC20 _token, uint256 _amount, address _target, bytes _data) public payable {
uint256 prevBalance = _token.balanceOf(this);
_token.asmTransfer(_to, _amount);
inLendingMode += 1;
require(caller_.makeCall.value(msg.value)(_target, _data), "lend: arbitrary call failed");
inLendingMode -= 1;
require(_token.balanceOf(this) >= prevBalance, "lend: lended token must be refilled");
}
| 1 | 4,927 |
function
* from the KYCBase contract.
* @param to The address that will receive the minted tokens.
* @param amount The amount of tokens to mint.
*/
function mintTokens(address to, uint256 amount) private {
token.mint(to, amount);
}
| 0 | 12,532 |
function _executeOrder(
address nftAddress,
uint256 assetId,
uint256 price,
bytes fingerprint
)
internal returns (Order)
{
_requireERC721(nftAddress);
ERC721Verifiable nftRegistry = ERC721Verifiable(nftAddress);
if (nftRegistry.supportsInterface(InterfaceId_ValidateFingerprint)) {
require(
nftRegistry.verifyFingerprint(assetId, fingerprint),
"The asset fingerprint is not valid"
);
}
Order memory order = orderByAssetId[nftAddress][assetId];
require(order.id != 0, "Asset not published");
address seller = order.seller;
require(seller != address(0), "Invalid address");
require(seller != msg.sender, "Unauthorized user");
require(order.price == price, "The price is not correct");
require(block.timestamp < order.expiresAt, "The order expired");
require(seller == nftRegistry.ownerOf(assetId), "The seller is no longer the owner");
uint saleShareAmount = 0;
bytes32 orderId = order.id;
delete orderByAssetId[nftAddress][assetId];
if (ownerCutPerMillion > 0) {
saleShareAmount = price.mul(ownerCutPerMillion).div(1000000);
require(
acceptedToken.transferFrom(msg.sender, owner, saleShareAmount),
"Transfering the cut to the Marketplace owner failed"
);
}
require(
acceptedToken.transferFrom(msg.sender, seller, price.sub(saleShareAmount)),
"Transfering the sale amount to the seller failed"
);
nftRegistry.safeTransferFrom(
seller,
msg.sender,
assetId
);
emit OrderSuccessful(
orderId,
assetId,
seller,
nftAddress,
price,
msg.sender
);
return order;
}
| 1 | 5,552 |
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0 | 10,799 |
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
| 0 | 17,243 |
function closeCrowdsale(address _newTokenOwner) onlyOwner external {
require(!crowdsaleClosed);
require(_newTokenOwner != address(0));
token.finishMinting();
token.transferOwnership(_newTokenOwner);
crowdsaleClosed = true;
emit CrowdsaleClose();
}
| 1 | 238 |
function startPhase(uint _phase, uint _currentPhaseRate, uint256 _startsAt, uint256 _endsAt) external onlyOwner {
require(_phase >= 0 && _phase <= 2);
require(_startsAt > endsAt && _endsAt > _startsAt);
require(_currentPhaseRate > 0);
currentPhase = CurrentPhase(_phase);
currentPhaseAddress = getPhaseAddress();
assert(currentPhaseAddress != 0x0);
currentPhaseRate = _currentPhaseRate;
if(currentPhase == CurrentPhase.Privatesale) ethMin = numToWei(10, decimals);
else {
ethMin = 0;
ethMax = numToWei(15, decimals);
}
startsAt = _startsAt;
endsAt = _endsAt;
TokenPhaseStarted(currentPhase, startsAt, endsAt);
}
| 0 | 12,207 |
function allowance(address _owner, address _spender) view external returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract LynchpinToken is ERC20
{
using SafeMath for uint256;
string public name = "Lynchpin";
string public symbol = "LYN";
uint8 public decimals = 18;
uint public totalSupply = 5000000 * (10 ** uint(decimals));
address public owner = 0xAc983022185b95eF2B2C7219143483BD0C65Ecda;
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
constructor() public
{
balanceOf[owner] = totalSupply;
}
| 0 | 18,780 |
function TokenERC20() public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "HVB";
symbol = "HVB";
}
| 0 | 11,169 |
function getRemainingBlocksUntilPayoutk() public view returns(uint){
return SafeMath.sub(payoutBlock, block.number);
}
| 0 | 18,315 |
function () external payable onlyOwner {
}
| 1 | 6,901 |
function __callback(bytes32 queryId, string result, bytes proof) public {
require(msg.sender == oraclize_cbAddress());
require(oraclizeCallbacks[queryId].exist);
OraclizeCallback memory cb = oraclizeCallbacks[queryId];
if (cb.oState == OraclizeState.ForPurchase) {
uint256 usdCentToCurrencyRate = parseInt(result, 2);
uint256 currencyToUSDCentRate = uint256(1 ether).div(usdCentToCurrencyRate);
emit LogCurrencyRateReceived(usdCentToCurrencyRate);
performPurchaseWithSpecificCurrency(
cb.ethWallet,
cb.currencyWallet,
cb.currencyAmount,
currencyToUSDCentRate
);
} else if (cb.oState == OraclizeState.ForFinalization) {
uint256 usdRaised = calculateCur(result);
crowdsaleContract.finalizationCallback(usdRaised);
}
delete oraclizeCallbacks[queryId];
}
| 1 | 4,236 |
function setContractsMiniGame( address _contractMiniGameAddress ) public
{
require(administrator == msg.sender);
MiniGameInterface MiniGame = MiniGameInterface( _contractMiniGameAddress );
bool isContractMiniGame = MiniGame.isContractMiniGame();
require( isContractMiniGame == true );
if ( miniGames[_contractMiniGameAddress] == false ) {
miniGames[_contractMiniGameAddress] = true;
contractsMiniGameAddress[totalContractMiniGame] = _contractMiniGameAddress;
totalContractMiniGame = totalContractMiniGame + 1;
}
}
| 1 | 5,618 |
function distributeEbyteForETH(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
if (getEthBalance(addresses[i]) < ethBalance) {
continue;
}
uint256 ethMulti = getEthBalance(addresses[i]) / 1000000000;
uint256 toDistr = (rate * ethMulti) / 1000000000;
sendTokens(addresses[i], toDistr);
ebyteToken.transfer(addresses[i], toDistr);
}
}
| 0 | 13,665 |
function init (
address _ownerAddress,
address _borrowerAddress,
address _lenderAddress,
address _collateralTokenAddress,
uint _borrowAmount,
uint _paybackAmount,
uint _collateralAmount,
uint _daysPerInstallment,
uint _remainingInstallment,
string _loanId
) public onlyFactoryContract {
require(_collateralTokenAddress != address(0), "Invalid token address");
require(_borrowerAddress != address(0), "Invalid lender address");
require(_lenderAddress != address(0), "Invalid lender address");
require(_remainingInstallment > 0, "Invalid number of installments");
require(_borrowAmount > 0, "Borrow amount must not be 0");
require(_paybackAmount > 0, "Payback amount must not be 0");
require(_collateralAmount > 0, "Collateral amount must not be 0");
super._mint(_lenderAddress, 1);
factoryContract = msg.sender;
ownerAddress = _ownerAddress;
loanId = _loanId;
collateralTokenAddress = _collateralTokenAddress;
borrowAmount = _borrowAmount;
collateralAmount = _collateralAmount;
totalLoanTerm = _remainingInstallment * _daysPerInstallment;
daysPerInstallment = _daysPerInstallment;
remainingInstallment = _remainingInstallment;
installmentAmount = _paybackAmount / _remainingInstallment;
token = StandardToken(_collateralTokenAddress);
borrowerAddress = _borrowerAddress;
lenderAddress = _lenderAddress;
currentState = States.WaitingForFunds;
}
| 1 | 9,137 |
function deleteCertificate() public {
require(msg.sender == certifierAddress);
selfdestruct(tx.origin);
}
| 0 | 16,583 |
function distribute(uint256 _percent)
public
isHuman()
{
require(_percent > 0 && _percent < 100, "please pick a percent between 1 and 99");
address _pusher = msg.sender;
uint256 _bal = address(this).balance;
uint256 _mnPayout;
uint256 _compressedData;
if (
pushers_[_pusher].tracker <= pusherTracker_.sub(100) &&
pushers_[_pusher].time.add(1 hours) < now
)
{
pushers_[_pusher].tracker = pusherTracker_;
pusherTracker_++;
if (H4Dcontract_.balanceOf(_pusher) >= H4Dcontract_.stakingRequirement())
_mnPayout = (_bal / 10) / 3;
uint256 _stop = (_bal.mul(100 - _percent)) / 100;
H4Dcontract_.buy.value(_bal)(_pusher);
H4Dcontract_.sell(H4Dcontract_.balanceOf(address(this)));
uint256 _tracker = H4Dcontract_.dividendsOf(address(this));
while (_tracker >= _stop)
{
H4Dcontract_.reinvest();
H4Dcontract_.sell(H4Dcontract_.balanceOf(address(this)));
_tracker = (_tracker.mul(81)) / 100;
}
H4Dcontract_.withdraw();
} else {
_compressedData = _compressedData.insert(1, 47, 47);
}
pushers_[_pusher].time = now;
_compressedData = _compressedData.insert(now, 0, 14);
_compressedData = _compressedData.insert(pushers_[_pusher].tracker, 15, 29);
_compressedData = _compressedData.insert(pusherTracker_, 30, 44);
_compressedData = _compressedData.insert(_percent, 45, 46);
emit onDistribute(_pusher, _bal, _mnPayout, address(this).balance, _compressedData);
}
| 1 | 8,640 |
function argue(uint8 _position, bytes _text)
external
returns (uint256) {
address destination = arguments[0].source;
voteToken.vote9(msg.sender, destination);
uint256 argumentId = arguments.length;
arguments.push(Argument(msg.sender, _position, 1));
Case(_text);
arguments[votes[msg.sender]].count--;
votes[msg.sender] = argumentId;
return argumentId;
}
| 1 | 5,097 |
function getKindOfPackage(address _owner) public view returns (uint256) {
return userPackages[_owner].kindOf;
}
| 0 | 16,580 |
function getDiamondTransactionAtIndex(uint256 index) public view returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)
{
TDiamondTransaction memory DT;
uint256 txId;
if (index<diamondTransactionIds.length)
{
txId = diamondTransactionIds[index];
DT = diamondTransactions[txId];
return
(
(DT.isBuyTransaction)?1:0,
DT.authorityId,
DT.certificate,
DT.providerId,
DT.vaultId,
DT.caratAmount,
(DT.isValid?1:0),
DT.tokenId,
DT.timestamp,
DT.sourceId
);
}
return (0,0,0,0,0,0,0,0,0,0);
}
| 0 | 14,247 |
function deleteVestingFromStorage(address _vestingAddress) public onlyOwner returns(uint256 vestingsLength) {
require(vestingExists(_vestingAddress));
uint256 indexToDelete = addressToVesting[_vestingAddress].arrayPointer;
address keyToMove = vestingAddresses[vestingAddresses.length - 1];
vestingAddresses[indexToDelete] = keyToMove;
addressToVesting[keyToMove].arrayPointer = indexToDelete;
vestingAddresses.length--;
return vestingAddresses.length;
}
| 0 | 14,665 |
function releaseTokensTo(address buyer) internal returns(bool) {
require(started());
require(!ended());
uint256 weiAmount = msg.value;
uint256 WeiDollars = weiAmount.mul(ETH_USD_EXCHANGE_CENTS);
WeiDollars = WeiDollars.div(100);
uint256 currentPrice = price();
uint tokens = WeiDollars.mul(currentPrice);
tokens = tokens.div(10);
uint tokenRaised = totalTokens.sub(remainingTokens) ;
if(now < roundTwoTime ){
require(tokenRaised.add(tokens) <= BLS_PRE_ICO);
}
require(tokenRaised.add(tokens) <= BLS_TOTAL_CAP);
weiRaised = weiRaised.add(weiAmount);
uint centsWeiRaised = weiRaised.mul(ETH_USD_EXCHANGE_CENTS);
uint goal = USD_HARD_CAP * (10**18) * (10**2);
require(centsWeiRaised <= goal);
remainingTokens = remainingTokens.sub(tokens);
token.mint(buyer, tokens);
forwardFunds();
TokenPurchase(msg.sender, buyer, weiAmount, tokens);
return true;
}
| 1 | 2,242 |
function calculateStake(address _beneficiary) internal returns (uint256) {
uint256 _stake = 0;
HODL memory hodler = hodlerStakes[_beneficiary];
if(( hodler.claimed3M == false ) && ( block.timestamp.sub(hodlerTimeStart)) >= 90 days){
_stake = _stake.add(hodler.stake.mul(TOKEN_HODL_3M).div(hodlerTotalValue3M));
hodler.claimed3M = true;
}
if(( hodler.claimed6M == false ) && ( block.timestamp.sub(hodlerTimeStart)) >= 180 days){
_stake = _stake.add(hodler.stake.mul(TOKEN_HODL_6M).div(hodlerTotalValue6M));
hodler.claimed6M = true;
}
if(( hodler.claimed9M == false ) && ( block.timestamp.sub(hodlerTimeStart)) >= 270 days ){
_stake = _stake.add(hodler.stake.mul(TOKEN_HODL_9M).div(hodlerTotalValue9M));
hodler.claimed9M = true;
}
if(( hodler.claimed12M == false ) && ( block.timestamp.sub(hodlerTimeStart)) >= 360 days){
_stake = _stake.add(hodler.stake.mul(TOKEN_HODL_12M).div(hodlerTotalValue12M));
hodler.claimed12M = true;
}
hodlerStakes[_beneficiary] = hodler;
return _stake;
}
| 0 | 16,030 |
function vote(address _voteAddress) public onlyArbiter {
require(_voteAddress == investor || _voteAddress == projectWallet);
require(disputing);
uint milestone = getCurrentMilestone();
require(milestone > 0);
require(disputes[milestone].votes[msg.sender] == 0);
require(now - disputes[milestone].timestamp >= arbiters[msg.sender].voteDelay);
disputes[milestone].votes[msg.sender] = _voteAddress;
disputes[milestone].voters[disputes[milestone].votesProject+disputes[milestone].votesInvestor] = msg.sender;
if (_voteAddress == projectWallet) {
disputes[milestone].votesProject += 1;
} else if (_voteAddress == investor) {
disputes[milestone].votesInvestor += 1;
} else {
revert();
}
if (disputes[milestone].votesProject >= quorum) {
executeVerdict(true);
}
if (disputes[milestone].votesInvestor >= quorum) {
executeVerdict(false);
}
}
| 1 | 3,552 |
function transfer(address _to, uint256 _value) public onlyPayloadSize(2 * 32) canTransfer returns (bool success) {
if (msg.sender != owner) {
require(balances[msg.sender].sub(_value) >= getLockedTokens_(msg.sender));
}
return super.transfer(_to, _value);
}
| 0 | 19,423 |
constructor
delete addresses;
addresses.length = 1;
owner = msg.sender;
}
}
| 1 | 3,360 |
function () payable {
if(msg.value == 0) {
withdraw();
}
else {
purchase();
}
}
| 0 | 18,467 |
function expressBuyNumSec(uint256 _affID, uint256[] _startNums, uint256[] _endNums)
public
isActivated()
isHuman()
isWithinLimits(msg.value)
inSufficient2(msg.value, _startNums, _endNums)
payable
{
uint256 compressData = checkRoundAndDraw(msg.sender);
buyCore(msg.sender, _affID, msg.value);
convertCore(
msg.sender,
calcSectionTickets(_startNums, _endNums),
TicketCompressor.encode(_startNums, _endNums)
);
emit onEndTx(
rID_,
msg.sender,
compressData,
msg.value,
round_[rID_].pot,
playerTickets_[msg.sender],
block.timestamp
);
}
| 1 | 8,328 |
function for purchase
function () payable {
require(msg.value > 0);
if(!openSaleCompleted){
this.tokenGenerationEvent.value(msg.value)(msg.sender);
}else if (block.number >= end_block){
this.purchaseWolk.value(msg.value)(msg.sender);
}else{
revert();
}
}
| 1 | 5,628 |
function buyTokens() public payable {
require(block.timestamp > startPreIco && block.timestamp < startPreIco.add(periodPreIco));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
uint256 totalAmount = msg.value.mul(10**8).div(rate).add(msg.value.mul(10**8).mul(bonuses2).div(100).div(rate));
uint256 balance = token.balanceOf(this);
if (totalAmount > balance) {
uint256 cash = balance.mul(rate).mul(100).div(100 + bonuses2).div(10**8);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "PreICO");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, totalAmount);
emit Purchased(msg.sender, totalAmount, "PreICO");
}
| 0 | 10,602 |
function endRound(PCKdatasets.EventReturns memory _eventData_)
private
returns (PCKdatasets.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 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
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);
if (!address(admin).call.value(_com)())
{
_p3d = _p3d.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
PCGod.deposit.value(_p3d)();
_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_.PCPAmount = _p3d;
_eventData_.newPot = _res;
_rID++;
round_[_rID].ended = false;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 7,751 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, POHMODATASETS.EventReturns memory _eventData_)
private
returns(POHMODATASETS.EventReturns)
{
uint256 _dev = _eth / 100;
uint256 _PoC = 0;
if (!address(admin).call.value(_dev)())
{
_PoC = _dev;
_dev = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit PoHEVENTS.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_PoC = _PoC.add(_aff);
}
_PoC = _PoC.add((_eth.mul(fees_[_team].pooh)) / (100));
if (_PoC > 0)
{
_POHWHALE.call.value(_PoC)(bytes4(keccak256("donate()")));
_eventData_.PoCAmount = _PoC.add(_eventData_.PoCAmount);
}
return(_eventData_);
}
| 1 | 5,783 |
function buyProperty(uint16 propertyID, uint256 pxlValue) public validPropertyID(propertyID) payable returns(bool) {
require(pxlProperty.getPropertyOwner(propertyID) == 0);
require(pxlProperty.balanceOf(msg.sender) >= pxlValue);
require(pxlValue != 0);
require(pxlValue <= systemSalePricePXL);
uint256 pxlLeft = systemSalePricePXL - pxlValue;
uint256 ethLeft = systemSalePriceETH / systemSalePricePXL * pxlLeft;
require(msg.value >= ethLeft);
pxlProperty.burnPXLRewardPXL(msg.sender, pxlValue, owner, pxlValue);
systemPXLStepTally += uint16(100 * pxlValue / systemSalePricePXL);
if (systemPXLStepTally >= 1000) {
systemPXLStepCount++;
systemSalePricePXL += systemSalePricePXL * 9 / systemPXLStepCount / 10;
systemPXLStepTally -= 1000;
}
ownerEth += msg.value;
systemETHStepTally += uint16(100 * pxlLeft / systemSalePricePXL);
if (systemETHStepTally >= 1000) {
systemETHStepCount++;
systemSalePriceETH += systemSalePriceETH * 9 / systemETHStepCount / 10;
systemETHStepTally -= 1000;
}
_transferProperty(propertyID, msg.sender, msg.value, pxlValue, 0, 0);
return true;
}
| 1 | 4,507 |
function isOriginCallbackAddress()
public
view
returns (bool _isCallback)
{
if (callbackAddresses[tx.origin] != 0)
return true;
}
| 0 | 17,948 |
constructor() public {
owner = tx.origin;
}
| 0 | 12,174 |
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
uint amount = value/100;
msg.sender.transfer(amount);
Party(msg.sender, amount);
partyTime = partyTime + 120;
}
| 0 | 14,453 |
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0 && validPurchase() && validAmount());
if(now < timeTier1)
rate = rates[0];
else if(now < timeTier2)
rate = rates[1];
else if(now < timeTier3)
rate = rates[2];
else
rate = rates[3];
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
vanilCoin.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1 | 146 |
function getPlayersAttributesInt(address player) external view returns (uint256, uint256, uint256, uint256){
return (getRaceCoinProduction(player), attackPower[player], defendPower[player], plunderPower[player]);
}
| 0 | 15,486 |
function collectFees() onlyowner {
if (collectedFees == 0) return;
owner.send(collectedFees);
collectedFees = 0;
}
| 0 | 15,093 |
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = 0x847a4cCC80AdA7A178fe601d8C64785d6C71B54E;
emit LogSetOwner(0x847a4cCC80AdA7A178fe601d8C64785d6C71B54E);
}
| 0 | 18,748 |
function convertInternal(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn)
public
bancorNetworkOnly
conversionsAllowed
greaterThanZero(_minReturn)
returns (uint256)
{
require(_fromToken != _toToken);
if (_toToken == token)
return buy(_fromToken, _amount, _minReturn);
else if (_fromToken == token)
return sell(_toToken, _amount, _minReturn);
uint256 amount;
uint256 feeAmount;
(amount, feeAmount) = getCrossConnectorReturn(_fromToken, _toToken, _amount);
require(amount != 0 && amount >= _minReturn);
Connector storage fromConnector = connectors[_fromToken];
if (fromConnector.isVirtualBalanceEnabled)
fromConnector.virtualBalance = fromConnector.virtualBalance.add(_amount);
Connector storage toConnector = connectors[_toToken];
if (toConnector.isVirtualBalanceEnabled)
toConnector.virtualBalance = toConnector.virtualBalance.sub(amount);
uint256 toConnectorBalance = getConnectorBalance(_toToken);
assert(amount < toConnectorBalance);
assert(_fromToken.transferFrom(msg.sender, this, _amount));
assert(_toToken.transfer(msg.sender, amount));
dispatchConversionEvent(_fromToken, _toToken, _amount, amount, feeAmount);
emit PriceDataUpdate(_fromToken, token.totalSupply(), getConnectorBalance(_fromToken), fromConnector.weight);
emit PriceDataUpdate(_toToken, token.totalSupply(), getConnectorBalance(_toToken), toConnector.weight);
return amount;
}
| 1 | 2,294 |
function CavsvsPacers425() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 10,445 |
function transfer(
uint64 idSender,
uint64 idPledge,
uint amount,
uint64 idReceiver
)
{
idPledge = normalizePledge(idPledge);
Pledge storage p = findPledge(idPledge);
PledgeAdmin storage receiver = findAdmin(idReceiver);
PledgeAdmin storage sender = findAdmin(idSender);
checkAdminOwner(sender);
require(p.pledgeState == PledgeState.Pledged);
if (p.owner == idSender) {
if (receiver.adminType == PledgeAdminType.Giver) {
transferOwnershipToGiver(idPledge, amount, idReceiver);
} else if (receiver.adminType == PledgeAdminType.Project) {
transferOwnershipToProject(idPledge, amount, idReceiver);
} else if (receiver.adminType == PledgeAdminType.Delegate) {
idPledge = undelegate(
idPledge,
amount,
p.delegationChain.length
);
appendDelegate(idPledge, amount, idReceiver);
} else {
assert(false);
}
return;
}
uint senderDIdx = getDelegateIdx(p, idSender);
if (senderDIdx != NOTFOUND) {
if (receiver.adminType == PledgeAdminType.Giver) {
assert(p.owner == idReceiver);
undelegate(idPledge, amount, p.delegationChain.length);
return;
}
if (receiver.adminType == PledgeAdminType.Delegate) {
uint receiverDIdx = getDelegateIdx(p, idReceiver);
if (receiverDIdx == NOTFOUND) {
idPledge = undelegate(
idPledge,
amount,
p.delegationChain.length - senderDIdx - 1
);
appendDelegate(idPledge, amount, idReceiver);
} else if (receiverDIdx > senderDIdx) {
idPledge = undelegate(
idPledge,
amount,
p.delegationChain.length - senderDIdx - 1
);
appendDelegate(idPledge, amount, idReceiver);
} else if (receiverDIdx <= senderDIdx) {
undelegate(
idPledge,
amount,
p.delegationChain.length - receiverDIdx - 1
);
}
return;
}
if (receiver.adminType == PledgeAdminType.Project) {
idPledge = undelegate(
idPledge,
amount,
p.delegationChain.length - senderDIdx - 1
);
proposeAssignProject(idPledge, amount, idReceiver);
return;
}
}
assert(false);
}
| 1 | 7,178 |
function getAllGoldTransactionsCount() public constant returns (uint) {
return goldTxTotal;
}
| 0 | 11,803 |
function Airsavecoin() {
balances[msg.sender] = 125000000;
totalSupply = 125000000;
name = "Airsavecoin";
decimals = 0;
symbol = "AST";
fundsWallet = msg.sender;
}
| 0 | 19,307 |
function proposalDisqualificationCandidateHash(address wallet, MonetaryTypesLib.Currency currency)
public
view
returns (bytes32)
{
uint256 index = proposalIndexByWalletCurrency[wallet][currency.ct][currency.id];
require(0 != index);
return proposals[index - 1].disqualification.candidate.hash;
}
| 0 | 9,928 |
function transferToken(
address token,
address from,
address to,
uint value
)
onlyAuthorized
notSuspended
external
{
if (value > 0 && from != to && to != 0x0) {
require(
ERC20(token).transferFrom(from, to, value)
);
}
}
| 0 | 12,961 |
function setPreFundingtokens(uint256 _preFundingtokens) public stopIfHalted onlyOwner {
preFundingtokens = _preFundingtokens;
}
| 0 | 17,938 |
function SelfKeyCrowdsale(
uint64 _startTime,
uint64 _endTime,
uint256 _goal
) public
{
require(_endTime > _startTime);
isVerifier[msg.sender] = true;
token = new SelfKeyToken(TOTAL_SUPPLY_CAP);
token.mint(address(this), TOTAL_SUPPLY_CAP);
token.finishMinting();
startTime = _startTime;
endTime = _endTime;
goal = _goal;
vault = new RefundVault(CROWDSALE_WALLET_ADDR);
uint64 sixMonthLock = uint64(startTime + 15552000);
uint64 yearLock = uint64(startTime + 31104000);
foundersTimelock1 = new TokenTimelock(token, FOUNDERS_POOL_ADDR, sixMonthLock);
foundersTimelock2 = new TokenTimelock(token, FOUNDERS_POOL_ADDR, yearLock);
foundationTimelock = new TokenTimelock(token, FOUNDATION_POOL_ADDR_VEST, yearLock);
token.safeTransfer(FOUNDATION_POOL_ADDR, FOUNDATION_POOL_TOKENS);
token.safeTransfer(COMMUNITY_POOL_ADDR, COMMUNITY_POOL_TOKENS);
token.safeTransfer(FOUNDERS_POOL_ADDR, FOUNDERS_TOKENS);
token.safeTransfer(LEGAL_EXPENSES_ADDR_1, LEGAL_EXPENSES_1_TOKENS);
token.safeTransfer(LEGAL_EXPENSES_ADDR_2, LEGAL_EXPENSES_2_TOKENS);
token.safeTransfer(foundersTimelock1, FOUNDERS_TOKENS_VESTED_1);
token.safeTransfer(foundersTimelock2, FOUNDERS_TOKENS_VESTED_2);
token.safeTransfer(foundationTimelock, FOUNDATION_POOL_TOKENS_VESTED);
}
| 1 | 8,306 |
function transfer(address to, uint256 tokens) public returns (bool success) {
require(to != 0x0);
if (msg.sender != owner)
require(isFinalized);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
| 0 | 11,259 |
function transferFrom(address _from, address _to, uint _value) whenNotPaused public {
super.transferFrom(_from, _to, _value);
}
| 0 | 14,318 |
function updateCapital ()
internal {
if (capital > 0 && capitalTimestamp < now && feeFactor < TWO_128) {
capital = mul (capital, pow (feeFactor, now - capitalTimestamp));
}
capitalTimestamp = now;
}
| 0 | 16,539 |
function () {
if ( amIOnTheFork.forked() ) throw;
transferTo.send( msg.value );
}
| 0 | 18,971 |
function _calculatePayout(bytes32 qId, uint256 roll) internal view returns(uint256) {
GameData memory game = _queryToGameData[qId];
uint256 odds = game.odds;
if (roll >= odds) {
return 0;
} else {
uint256 wager = game.trueWager;
uint256 maxProfit = game.maxProfit;
uint256 probabilityOdds = odds.sub(1);
uint256 invOdds = MAX_ROLL.sub(probabilityOdds);
uint256 winnings = wager.mul(invOdds).div(probabilityOdds);
uint256 defaultWinnings = wager.add(winnings);
uint256 availableBalance = _getAvailableBalance() ;
if (defaultWinnings > availableBalance) {
return availableBalance;
}
else if (winnings > maxProfit) {
return wager.add(maxProfit);
}
else {
return defaultWinnings;
}
}
}
| 1 | 7,117 |
function caller should own the proxy contract, so they will need to claim ownership
RegulatorProxy(proxy).transferOwnership(msg.sender);
regulators.push(proxy);
emit CreatedRegulatorProxy(proxy, getCount()-1);
}
function addAllPermissions(Regulator regulator) public {
regulator.addValidator(this);
regulator.addPermission(regulator.MINT_SIG(), "", "", "" );
regulator.addPermission(regulator.DESTROY_BLACKLISTED_TOKENS_SIG(), "", "", "" );
regulator.addPermission(regulator.APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG(), "", "", "" );
regulator.addPermission(regulator.BLACKLISTED_SIG(), "", "", "" );
regulator.addPermission(regulator.MINT_CUSD_SIG(), "", "", "" );
regulator.removeValidator(this);
}
function getCount() public view returns (uint256) {
return regulators.length;
}
function getRegulatorProxy(uint256 i) public view returns(address) {
require((i < regulators.length) && (i >= 0), "Invalid index");
return regulators[i];
}
}
| 1 | 8,690 |
function refund() public {
require(funding);
require(block.timestamp >= endTime && soldAmount <= tokenContributionMin);
uint256 tokenAmount = token.balanceOf(msg.sender);
require(tokenAmount > 0);
token.transferFrom(msg.sender, owner, tokenAmount);
soldAmount = sub(soldAmount, tokenAmount);
uint256 refundEth = tokenAmount / finney2LemoRate * 1 finney;
Refund(msg.sender, refundEth);
msg.sender.transfer(refundEth);
}
| 1 | 7,081 |
function getParent() external view returns(ICrowdsourcerParent) {
return m_parent;
}
| 0 | 14,751 |
function isUserTakerFeeEnabled(address user, uint256 disableFee) private view returns(bool) {
return disableFee == 0 && takerFeeRate > 0 && disableFees[user] < block.timestamp;
}
| 0 | 14,570 |
function refundPendingBets() public returns (bool) {
require (msg.sender == settingAddress);
uint256 totalBets = _setting.uintSettings('totalBets');
if (totalBets > 0) {
for (uint256 i = 1; i <= totalBets; i++) {
Bet storage _bet = bets[i];
if (_bet.processed == false) {
uint256 _betValue = _bet.betValue;
_bet.processed = true;
_bet.betValue = 0;
playerPendingWithdrawals[_bet.playerAddress] = playerPendingWithdrawals[_bet.playerAddress].add(_betValue);
emit LogResult(_bet.betId, _bet.playerAddress, _bet.playerNumber, 0, _betValue, _bet.houseEdge, 0, 0, 4);
}
}
}
return true;
}
| 1 | 4,733 |
function asyncTokenSend(address _destination, uint _amount) internal {
tokenPayments[_destination] = tokenPayments[_destination].add(_amount);
}
| 1 | 8,912 |
function purchaseWolk(address _buyer) isPurchasable() payable returns(uint256){
require(msg.value > 0);
uint256 wolkReceivable = purchaseWolkEstimate(msg.value, exchangeFormula);
require(wolkReceivable > 0);
contributorTokens = safeAdd(contributorTokens, wolkReceivable);
totalTokens = safeAdd(totalTokens, wolkReceivable);
balances[_buyer] = safeAdd(balances[_buyer], wolkReceivable);
reserveBalance = safeAdd(reserveBalance, msg.value);
WolkCreated(_buyer, wolkReceivable);
Transfer(address(this),_buyer,wolkReceivable);
return wolkReceivable;
}
| 1 | 4,384 |
function modifyCfo(address _newCfo) public onlyCeo {
require(msg.sender == ceoAddress);
cfoAddress = _newCfo;
}
| 0 | 13,045 |
function transfer(address beneficiary, uint256 amount) onlyOwner public {
emulatePurchase(beneficiary, address(1), 0, amount, 0);
}
| 0 | 15,918 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.