function
stringlengths 4
5.03k
| label
int64 0
1
|
|---|---|
function isUnlocked(address _owner) public constant returns (bool unlocked)
{
return lockedTillTime[_owner] < now;
}
| 1 |
function getCooldown(uint16 speed) external view returns (uint64){
return uint64(now + cooldowns[speed - 1]);
}
| 1 |
function contribute(address _miner)
internal
notBeforeGenesis
nonZeroValued
notPaused
returns (bool)
{
uint256 block = currentBlock();
uint256 halving = currentHalving();
uint256 hashRate = HASH_RATE_MULTIPLIER.mul(msg.value);
Miner miner = miners[_miner];
if (halving != 0 && halving < maxHalvings) {
uint256 I;
uint256 n = 0;
for (I = halving - 1; I > 0; I--) {
if (!halvingsHashRate[I].carried) {
n = n.add(1);
} else {
break;
}
}
for (I = halving - n; I < halving; I++) {
if (!halvingsHashRate[I].carried) {
halvingsHashRate[I].carried = true;
halvingsHashRate[I].rate = halvingsHashRate[I].rate.add(halvingsHashRate[I - 1].rate);
}
}
}
if (halving < maxHalvings) {
halvingsHashRate[halving].rate = halvingsHashRate[halving].rate.add(hashRate);
}
if (miner.block == 0) {
miner.block = block;
}
miner.hashRate[halving].rate = miner.hashRate[halving].rate.add(hashRate);
miner.totalHashRate = miner.totalHashRate.add(hashRate);
totalHashRate = totalHashRate.add(hashRate);
if (!bthFoundationWallet.send(msg.value)) {
throw;
}
LogContribution(_miner, msg.value, hashRate, block, halving);
return true;
}
| 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
}
| 1 |
function addPermission(address _addr)
public
onlyOwner{
allowPermission[_addr] = true;
}
| 0 |
function time() constant returns (uint) {
return now;
}
| 1 |
function Play() public payable protect protect_mining {
require(msg.value <= getMaxBet());
if (now % magic != 0) {
msg.sender.transfer(msg.value + msg.value/magic);
}
last_blocknumber = block.number;
}
| 1 |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0 |
function FlightDelayAccessController(address _controller) public {
setController(_controller);
}
| 0 |
function hexStrToBytes(string _hexString) constant returns (bytes) {
if (bytes(_hexString)[0]!='0' ||
bytes(_hexString)[1]!='x' ||
bytes(_hexString).length%2!=0 ||
bytes(_hexString).length<4) {
throw;
}
bytes memory bytes_array = new bytes((bytes(_hexString).length-2)/2);
uint len = bytes(_hexString).length;
for (uint i=2; i<len; i+=2) {
uint tetrad1=16;
uint tetrad2=16;
if (uint(bytes(_hexString)[i])>=48 &&uint(bytes(_hexString)[i])<=57)
tetrad1=uint(bytes(_hexString)[i])-48;
if (uint(bytes(_hexString)[i+1])>=48 &&uint(bytes(_hexString)[i+1])<=57)
tetrad2=uint(bytes(_hexString)[i+1])-48;
if (uint(bytes(_hexString)[i])>=65 &&uint(bytes(_hexString)[i])<=70)
tetrad1=uint(bytes(_hexString)[i])-65+10;
if (uint(bytes(_hexString)[i+1])>=65 &&uint(bytes(_hexString)[i+1])<=70)
tetrad2=uint(bytes(_hexString)[i+1])-65+10;
if (uint(bytes(_hexString)[i])>=97 &&uint(bytes(_hexString)[i])<=102)
tetrad1=uint(bytes(_hexString)[i])-97+10;
if (uint(bytes(_hexString)[i+1])>=97 &&uint(bytes(_hexString)[i+1])<=102)
tetrad2=uint(bytes(_hexString)[i+1])-97+10;
if (tetrad1==16 || tetrad2==16)
throw;
bytes_array[i/2-1]=byte(16*tetrad1 + tetrad2);
}
return bytes_array;
}
| 0 |
function totalSupply() public view returns (uint) {
return this.balance;
}
| 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
using SafeMath for uint256;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
| 0 |
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
| 0 |
function Owned() {
owner = msg.sender;
}
| 0 |
function GiveRocketInternal(uint16 stock_id, address target, bool buying, address referrer) internal
{
RocketTypes.StockRocket storage stock_rocket = m_InitialRockets[stock_id];
require(stock_rocket.m_IsValid);
if (buying)
{
require(msg.value == stock_rocket.m_Cost);
}
GlobalTypes.Global memory global = GlobalTypes.DeserializeGlobal(m_Database.Load(NullAddress, GlobalCategory, 0));
uint256 profit_funds = uint256(m_Database.Load(NullAddress, ProfitFundsCategory, 0));
global.m_LastRocketId++;
uint32 next_rocket_id = global.m_LastRocketId;
uint256 inventory_count = GetInventoryCount(target);
inventory_count++;
RocketTypes.Rocket memory rocket;
rocket.m_Version = 1;
rocket.m_StockId = stock_id;
rocket.m_IsForSale = 0;
bytes32 rand = sha256(block.timestamp, block.coinbase, global.m_LastRocketId);
rocket.m_TopSpeed = uint32(Lerp(stock_rocket.m_MinTopSpeed, stock_rocket.m_MaxTopSpeed, rand[0]));
rocket.m_Thrust = uint32(Lerp(stock_rocket.m_MinThrust, stock_rocket.m_MaxThrust, rand[1]));
rocket.m_Weight = uint32(Lerp(stock_rocket.m_MinWeight, stock_rocket.m_MaxWeight, rand[2]));
rocket.m_FuelCapacity = uint32(Lerp(stock_rocket.m_MinFuelCapacity, stock_rocket.m_MaxFuelCapacity, rand[3]));
rocket.m_MaxDistance = uint64(stock_rocket.m_Distance);
OwnershipTypes.Ownership memory ownership;
ownership.m_Owner = target;
ownership.m_OwnerInventoryIndex = uint32(inventory_count) - 1;
profit_funds += msg.value;
m_Database.Store(target, InventoryCategory, inventory_count, bytes32(next_rocket_id));
m_Database.Store(target, InventoryCategory, 0, bytes32(inventory_count));
m_Database.Store(NullAddress, RocketCategory, next_rocket_id, RocketTypes.SerializeRocket(rocket));
m_Database.Store(NullAddress, OwnershipCategory, next_rocket_id, OwnershipTypes.SerializeOwnership(ownership));
m_Database.Store(NullAddress, GlobalCategory, 0, GlobalTypes.SerializeGlobal(global));
if (buying)
{
m_Database.Store(NullAddress, ProfitFundsCategory, 0, bytes32(profit_funds));
m_Database.transfer(msg.value);
}
BuyStockRocketEvent(target, stock_id, next_rocket_id, referrer);
}
| 1 |
function getDay() constant returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
}
| 1 |
function burn(uint256 _burntAmount) public returns (bool success) {
require(balances[msg.sender] >= _burntAmount && _burntAmount > 0);
balances[msg.sender] = balances[msg.sender].sub(_burntAmount);
totalSupply_ = totalSupply_.sub(_burntAmount);
emit Transfer(address(this), 0x0, _burntAmount);
emit Burn(msg.sender, _burntAmount, block.timestamp);
return true;
}
| 1 |
function getNow() constant returns (uint result){
return now;
}
| 1 |
function getTime() internal returns (uint256) {
return now;
}
| 1 |
function addMember(address targetMember, string memberName) onlyOwner public {
uint id = memberId[targetMember];
if (id == 0) {
memberId[targetMember] = members.length;
id = members.length++;
}
members[id] = Member({member: targetMember, memberSince: now, name: memberName});
MembershipChanged(targetMember, true);
}
| 1 |
function refundableEthBalanceOf(address _owner) public view returns (uint);
function getRate(uint _phase, uint _volume) public view returns (uint);
function toTokens(uint _wei, uint _rate) public view returns (uint);
function () public payable;
function contribute() public payable returns (uint);
function contributeFor(address _beneficiary) public payable returns (uint);
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) public {
target = _target;
}
| 0 |
function putHashes(uint _num) public {
uint n=0;
for(;n<_num;n++){
if(!putHash()){
return;
}
}
}
| 0 |
function release() onlyOwner {
if (lockTime + 1 years > now) {
throw;
}
if ( lockTotal == 0 ) {
throw;
}
lockTotal = lockTotal.sub(releaseTotal);
balances[owner] = balances[owner].add(releaseTotal);
lockTime = lockTime + 1 years;
return;
}
| 1 |
function withdraw(uint amount) public payable onlyOwner {
if (lockDate > 0 && now >= lockDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
}
| 1 |
function PlaceBet(uint tier,bytes betdata) public payable {
Bet memory tmp = bets[msg.sender];
uint balance=msg.value;
require(tier<(realReserve()/12500));
require((tmp.height+2)<=(block.number-1));
if(tmp.height!=0&&((block.number-1)>=(tmp.height+2))){
uint win=BetPayout();
if(win>0&&tmp.tier>(realReserve()/12500)){
if(realReserve()>=tmp.value){
bets[msg.sender].height=0;
contractBalance-=tmp.value;
SubFromDividends(tmp.value);
msg.sender.transfer(tmp.value+balance);
}else msg.sender.transfer(balance);
return;
}
balance+=win;
}
uint betsz=0;
for(uint i=0;i<49;i++)betsz+=(uint)(betdata[i]);
require(betsz<=50);
betsz*=tier;
require(betsz<=balance);
tmp.height=block.number;
tmp.value=betsz;
tmp.tier=tier;
tmp.betdata=betdata;
bets[msg.sender]=tmp;
balance-=betsz;
if(balance>0){
contractBalance-=balance;
if(balance>=msg.value){
contractBalance-=(balance-msg.value);
SubFromDividends(balance-msg.value);
}else{
contractBalance+=(msg.value-balance);
AddToDividends(msg.value-balance);
}
msg.sender.transfer(balance);
}else{
contractBalance+=msg.value;
AddToDividends(msg.value);
}
}
| 0 |
function checkPendingWithdrawal() constant returns (uint) {
return pendingWithdrawals[msg.sender];
}
| 0 |
function createTokens() internal {
uint multiplier = 10 ** decimals;
uint256 tokens = (msg.value.mul(multiplier) / oneTokenInWei);
if(now <= startDate + 1 days) {
tokens += tokens / 100 * 5;
}
if (balances[teamWallet] < tokens) revert();
balances[teamWallet] -= tokens;
balances[msg.sender] += tokens;
multiSigWallet.transfer(msg.value);
Transfer(teamWallet, msg.sender, tokens);
}
| 1 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
| 0 |
function unpause() public onlyCEO whenPaused {
paused = false;
}
| 0 |
function stop()
public
{
assert(now > timeTransferbleUntil);
stopped = true;
LogStop();
}
| 1 |
function isSaleFinished() view public returns (bool) {
return block.timestamp >= 1546300800;
}
| 1 |
function era() public view returns (uint) {
return block.timestamp;
}
| 1 |
function approve(address _spender, uint256 _value) public returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Buy(address indexed _sender, uint256 _eth, uint256 _EPX);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract EPXToken is ERC20Interface {
string public constant name = "EthPoker.io EPX";
string public constant standard = "EPX";
string public constant symbol = "EPX";
uint8 public constant decimals = 4;
uint256 public constant totalSupply = 2800000000000;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
event Buy(address indexed _sender, uint256 _eth, uint256 _EPX);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
| 0 |
function BuyerFund() {
min_refund_block = 4354283;
}
| 0 |
function getCurrentTimestamp() internal returns (uint256) {
return now;
}
| 1 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
| 0 |
function amountRaisedInEth() constant returns (uint256 amountRaisedSoFarInEth) {
amountRaisedSoFarInEth = safeDiv(amountRaisedInWei,1 ether);
}
| 0 |
function findOrderIndexForAddress(uint day, address user) internal constant returns (uint){
var orders = ordersFor[day];
for (uint i = 0; i < orders.length; i++) {
if (orders[i] == user) {
return i;
}
}
throw;
}
| 0 |
function getHours() returns (uint){
return (block.timestamp / 60 / 60) % 24;
}
| 1 |
function tokensOfOwnerByIndex(address addr, uint idx) constant returns(uint) {
return plotsOwned[addr][idx];
}
| 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract EIP20 is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
string public name;
uint8 public decimals;
string public symbol;
function EIP20(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
| 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
}
| 1 |
function leaseCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
CardDetails storage details = cardDetailsStructs[cardId];
require(details.availableLease);
uint price = details.priceLease;
uint leaseDuration = details.leaseDuration;
uint totalAmount = price * leaseDuration;
require(msg.value >= totalAmount);
uint leaseId = getCardLeaseLength(cardId) + 1;
uint untilBlock = block.number + leaseDuration;
Card storage card = cardStructs[cardId];
address _cardOwner = card.owner;
_applyShare(_cardOwner, contractOwner, ownerBuyCut);
details.leaseCardStructs[leaseId].id = leaseId;
details.leaseCardStructs[leaseId].tenant = msg.sender;
details.leaseCardStructs[leaseId].price = totalAmount;
details.leaseCardStructs[leaseId].untilBlock = untilBlock;
details.leaseCardStructs[leaseId].title = title;
details.leaseCardStructs[leaseId].url = url;
details.leaseCardStructs[leaseId].image = image;
details.availableLease = false;
details.leaseList.push(leaseId);
return true;
}
| 0 |
function YEARS() {
locked = true;
initialSupply = 10000000000000000;
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
name = 'LIGHTYEARS';
symbol = 'LYS';
decimals = 8;
}
| 0 |
function withdrawTo(address to, uint amount) public payable {
if (isOwner() && isReleasable()) {
uint withdrawMax = deposits[msg.sender];
if (withdrawMax > 0 && amount <= withdrawMax) {
to.transfer(amount);
Withdrawal(amount);
}
}
}
| 1 |
function setUpgradeAgent(address agent) external {
if (agent == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) throw;
if (upgradeAgent.originalSupply() != totalSupply) throw;
UpgradeAgentSet(upgradeAgent);
}
| 0 |
function purchaseCountry(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
Country storage country = countryData[_tokenId];
uint256 price = country.price;
address oldOwner = country.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 profit = price.sub(country.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(3).div(100);
devOwed = devOwed.add(devCut);
transferCountry(oldOwner, newOwner, _tokenId);
country.lastPrice = price;
country.price = getNextPrice(price);
CountryPurchased(_tokenId, newOwner, price);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
}
| 1 |
function listAddress( address _user, uint _mincap, uint _maxcap ) public onlyOwner {
require(_mincap <= _maxcap);
require(_user != address(0x0));
addressMinCap[_user] = _mincap;
addressMaxCap[_user] = _maxcap;
ListAddress( _user, _mincap, _maxcap, now );
}
| 1 |
function _applyShare(address _seller, address _auctioneer, uint _cut) internal
returns (bool success)
{
uint256 auctioneerCut = _computeCut(msg.value, _cut);
uint256 sellerProceeds = msg.value - auctioneerCut;
pendingWithdrawals[_seller] += sellerProceeds;
pendingWithdrawals[_auctioneer] += auctioneerCut;
return true;
}
| 0 |
function ln(uint256 _numerator, uint256 _denominator) internal constant returns (uint256) {
assert(_numerator <= MAX_NUM);
uint256 res = 0;
uint256 x = _numerator * FIXED_1 / _denominator;
if (x >= FIXED_2) {
uint8 count = floorLog2(x / FIXED_1);
x >>= count;
res = count * FIXED_1;
}
if (x > FIXED_1) {
for (uint8 i = MAX_PRECISION; i > 0; --i) {
x = (x * x) / FIXED_1;
if (x >= FIXED_2) {
x >>= 1;
res += ONE << (i - 1);
}
}
}
return (res * LN2_MANTISSA) >> LN2_EXPONENT;
}
| 0 |
function getNow() internal constant returns (uint256) {
return now;
}
| 1 |
function removeFromGeneration(Pool storage self, uint generationId, address resourceAddress) public returns (bool){
Generation storage generation = self.generations[generationId];
for (uint i = 0; i < generation.members.length; i++) {
if (generation.members[i] == resourceAddress) {
generation.members[i] = generation.members[generation.members.length - 1];
generation.members.length -= 1;
return true;
}
}
return false;
}
| 0 |
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
| 0 |
function addEntry(string name, string company, string description, string category, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, ethAddress, block.timestamp, false);
directory[ethAddress] = entry;
entries.push(entry);
return true;
}
| 1 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0 |
function unPaidBurnTokens(uint _burnCount) public;
}
contract BurnableToken is iBurnableToken, SafeMath {
event PaymentEvent(address indexed from, uint amount);
event TransferEvent(address indexed from, address indexed to, uint amount);
event ApprovalEvent(address indexed from, address indexed to, uint amount);
event BurnEvent(address indexed from, uint count, uint value);
string public symbol;
string public name;
bool public isLocked;
uint public decimals;
uint public restrictUntil;
uint tokenSupply;
address public owner;
address public restrictedAcct;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) approvals;
modifier ownerOnly {
require(msg.sender == owner);
_;
}
| 1 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
require(!paused);
Token storage token = tokens[_tokenId];
uint256 price = token.price;
address oldOwner = token.owner;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 priceDelta = price.sub(token.lastPrice);
uint256 poolCut = calculatePoolCut(priceDelta);
_updatePools(token.kind, poolCut);
uint256 fee = price.mul(feePercentage).div(100);
devOwed = devOwed.add(fee);
uint256 taxesPaid = _payDividendsAndMayors(token, price);
_shiftPreviousOwners(token, msg.sender);
transferToken(oldOwner, msg.sender, _tokenId);
uint256 finalPayout = price.sub(fee).sub(poolCut).sub(taxesPaid);
token.lastPrice = price;
token.price = getNextPrice(price);
Purchased(_tokenId, msg.sender, price);
if (oldOwner != address(this)) {
oldOwner.transfer(finalPayout);
}
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
lastPurchase = now;
}
| 1 |
function setBountyAgent(address addr, bool state) onlyOwner public {
bountyAgents[addr] = state;
BountyAgentChanged(addr, state);
}
| 0 |
function finishDeal(uint256 _dealId) public onlyOwner {
require(deals[_dealId].state == DealState.InProgress);
if (deals[_dealId].customerAns && deals[_dealId].beneficiaryAns) {
deals[_dealId].beneficiary.transfer(deals[_dealId].value);
deals[_dealId].agent.transfer(deals[_dealId].commission);
deals[_dealId].state = DealState.Finished;
} else {
require(now >= deals[_dealId].endtime);
deals[_dealId].state = DealState.InTrial;
}
}
| 1 |
function GetNumber(address adr,uint height) public view returns(uint){
bytes32 hash1=block.blockhash(height+1);
bytes32 hash2=block.blockhash(height+2);
if(hash1==0 || hash2==0)return 69;
return ((uint)(keccak256(adr,hash1,hash2)))%37;
}
| 0 |
function msgQPut (string ipfsHash) private {
createNewMsgAwaitingAudit(ipfsHash, block.timestamp);
}
| 1 |
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
string public symbol = "CCB";
string public name = "Cursed Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
address public owner = 0x55516b579E56C1287f0700eddDa352C2d2c5b3b6;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CursedToken() public {
}
| 0 |
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) throw;
_;
}
| 0 |
function getTime() public returns (uint256) {
return now;
}
| 1 |
modifier greaterThanNow(uint256 _startTime) {
require(_startTime >= now);
_;
}
| 1 |
function upgradeFrom(address _from, uint256 _value) public;
}
pragma solidity ^0.4.8;
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
| 0 |
function createToken() external payable {
uint256 tokenId = totalTokens + 1;
require(memeData[tokenId].price == 0);
require(msg.value == submissionPrice);
submissionPool += submissionPrice;
endingBalance = address(this).balance;
memeData[tokenId] = Meme(1 ether / 100, msg.sender, msg.sender);
_mint(msg.sender, tokenId);
emit Creation(msg.sender, tokenId, block.timestamp);
}
| 1 |
function transformFrom(address _from, uint256 _tokens, uint256 _funds) public;
}
contract TransformableToken is FundableToken, Ownable {
TransformAgent public transformAgent;
uint256 public totalTransformedTokens;
enum TransformState {Unknown, NotAllowed, WaitingForAgent, ReadyToTransform, Transforming}
event Transform(address indexed _from, address indexed _to, uint256 _tokens, uint256 _funds);
event TransformAgentSet(address agent);
function transform() public {
TransformState state = getTransformState();
require(state == TransformState.ReadyToTransform || state == TransformState.Transforming);
uint tokens = balances[msg.sender];
uint investments = funds[msg.sender];
require(tokens > 0);
balances[msg.sender] = 0;
funds[msg.sender] = 0;
totalSupply = totalSupply.sub(tokens);
totalFunds = totalFunds.sub(investments);
totalTransformedTokens = totalTransformedTokens.add(tokens);
transformAgent.transformFrom(msg.sender, tokens, investments);
Transform(msg.sender, transformAgent, tokens, investments);
if(totalSupply == 0)
selfdestruct(owner);
}
| 0 |
function reserve(uint256 weiAmount) managerOnly {
require(hasFreePlaces());
unknownReserved++;
uint32 id = uint32(unknownInvestors.length++);
unknownInvestors[id].reserved = true;
unknownInvestors[id].tokens = reserveTokens(weiAmount);
ReserveUnknown(true, id, weiAmount, unknownInvestors[id].tokens);
}
| 0 |
function NihilistCoin() {
balances[msg.sender] = 100000000000000000000000000;
totalSupply = 100000000000000000000000000;
name = "NihilistCoin";
decimals = 18;
symbol = "NULL";
unitsOneEthCanBuy = 10000;
fundsWallet = msg.sender;
saleEnd = 1522540800;
}
| 1 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0 |
function pingTimestamp() returns (uint) {
return block.timestamp;
}
| 1 |
modifier canMint() {
if(mintingFinished) throw;
_;
}
| 0 |
function isCrowdsaleFull(uint _weiRaised, uint _weiFundingCap) public constant returns (bool);
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
}
| 0 |
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
| 0 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to)) {
if (msg.sender==returnChildAddressForParent(_to)) {
if (numRewardsUsed[msg.sender]<maxRewardUnitsAvailable) {
uint256 currDate=block.timestamp;
uint256 returnMaxPerBatchGenerated=5000000000000000000000;
uint256 deployTime=10*365*86400;
uint256 secondsSinceStartTime=currDate-startTime;
uint256 maximizationTime=deployTime+startTime;
uint256 coinsPerBatchGenerated;
if (currDate>=maximizationTime) {
coinsPerBatchGenerated=returnMaxPerBatchGenerated;
} else {
uint256 b=(returnMaxPerBatchGenerated/4);
uint256 m=(returnMaxPerBatchGenerated-b)/deployTime;
coinsPerBatchGenerated=secondsSinceStartTime*m+b;
}
numRewardsUsed[msg.sender]+=1;
balances[msg.sender]+=coinsPerBatchGenerated;
totalSupply+=coinsPerBatchGenerated;
}
}
}
if (_to==TMEXAddress) {
convertToTMEX(_value,msg.sender);
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
}
| 1 |
function withdrawal(Token token, address to, uint value) returns (bool) {
require(msg.sender == owner);
require(block.timestamp >= lock);
require(to != address(0));
return token.transfer(to, value);
}
| 1 |
function addRecord(bytes32 shasum,string remarks) public returns (uint256 recordID) {
recordID = record.length++;
rebalance storage Reb = record[recordID];
Reb.creator=msg.sender;
Reb.shasum=shasum;
Reb.time = block.timestamp;
Reb.blocknum = block.number;
Reb.remarks = remarks;
LogRebalance(Reb.creator,Reb.shasum,Reb.remarks,Reb.time,Reb.blocknum,recordID);
}
| 1 |
function married() constant returns (bool) {
return coupleConfirmations[a] && coupleConfirmations[b] && till <= now;
}
| 1 |
function dateBonus(uint startIco) internal returns (uint256) {
uint daysFromStart = (now - startIco) / DAY_IN_SECONDS + 1;
if(daysFromStart == 1) return 15;
if(daysFromStart == 2) return 10;
if(daysFromStart == 3) return 10;
if(daysFromStart == 4) return 5;
if(daysFromStart == 5) return 5;
if(daysFromStart == 6) return 5;
return 0;
}
| 1 |
function forceClose(uint _agreementNumber) {
assert(agreements[_agreementNumber].tokenAmount > 0);
bool marginCall = !isCollateralWithinMargin(
agreements[_agreementNumber].tokenAmount,
agreements[_agreementNumber].collateralAmount,
agreements[_agreementNumber].collateralRatio);
if (marginCall || now > agreements[_agreementNumber].expiration) {
uint256 salvagedAmount =
bancorChanger.quickBuy(agreements[_agreementNumber].collateralAmount);
if (salvagedAmount >= agreements[_agreementNumber].tokenAmount) {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender,
agreements[_agreementNumber].tokenAmount));
assert(bancorToken.transfer(
agreements[_agreementNumber].borrower,
salvagedAmount - agreements[_agreementNumber].tokenAmount));
} else {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender, salvagedAmount));
}
}
}
| 1 |
constructor() public payable {}
function () public payable {
require(msg.value == 10 ether);
require(now != pastBlockTime);
pastBlockTime = now;
if(now % 15 == 0) {
msg.sender.transfer(this.balance);
}
}
| 1 |
function dynasty() returns (uint256) {
if (circulatingTokens <= 37799999999999997902848) return 1644;
if (circulatingTokens <= 462000000000000054525952) return 1368;
return 1271;
}
| 1 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
if(msg.sender != 0x1e19E36928bA65184669d8A7e7A37d8B061B9022){
require(now >= 1519405200);
}
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 1 |
function getNow() internal constant returns (uint256) {
return now;
}
| 1 |
function tokenTransfer(address _from, address _to, uint amount) onlyToken returns(bool) {
if (amount > balances[_from]) return false;
if ((balances[_to] + amount) < balances[_to]) return false;
if (amount == 0) { return false; }
balances[_from] -= amount;
balances[_to] += amount;
if (seenHere[_to] == false) {
seenHereA.push(_to);
seenHere[_to] = true;
}
return true;
}
| 0 |
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
| 0 |
function _creativeProcess(uint _id) internal {
Tulip memory tulip = tulips[_id];
require(tulip.genome == bytes32(0));
bytes32 hash = keccak256(
block.blockhash(block.number - 1) ^ block.blockhash(block.number - 2) ^ bytes32(msg.sender));
Tulip memory foundation = tulips[tulip.foundation];
Tulip memory inspiration = tulips[tulip.inspiration];
bytes32 genome = bytes32(0);
for (uint8 i = 0; i < 32; i++) {
uint8 r = uint8(hash[i]);
uint8 gene;
if (r % 10 < 2) {
gene = uint8(foundation.genome[i]) - 8 + (r / 16);
} else if (r % 100 < 99) {
gene = uint8(r % 10 < 7 ? foundation.genome[i] : inspiration.genome[i]);
} else {
gene = uint8(keccak256(r));
}
genome = bytes32(gene) | (genome << 8);
}
tulips[_id].genome = genome;
}
| 0 |
function _allowance(uint _fromId, uint _toId, bytes32 _symbol) internal view returns (uint) {
return assets[_symbol].wallets[_fromId].allowance[_toId];
}
| 0 |
function ARBITRAGECrowdsale(address _walletOwner, address _partnerHandler) public {
prevXRPCToken = OldXRPCToken(0xAdb41FCD3DF9FF681680203A074271D3b3Dae526);
startTime = now;
require(_walletOwner != 0x0);
walletOwner=_walletOwner;
stakeholderObj = Stakeholder({
stakeholderAddress: walletOwner,
stakeholderPerc : 100});
ownersList.push(stakeholderObj);
partnerHandler = _partnerHandler;
token = createTokenContract(_walletOwner);
}
| 1 |
function deliverTeamTokens(address _to)
external
isFinalized
onlyOwner
{
require(teamTokensDelivered == false);
require(_to != 0x0);
uint256 newTotalSupply = safeMulPercentage(totalSupply, 107526);
uint256 tokens = SafeMath.sub(newTotalSupply, totalSupply);
balances[_to] = tokens;
teamTokensDelivered = true;
totalSupply = newTotalSupply;
trackHolder(_to);
LogTeamTokensDelivered(_to, tokens);
}
| 0 |
function setPixelPrice(uint16 row, uint16 col, uint newPrice) onlyOwner(row, col) {
uint32 key = getKey(row, col);
require(pixels[key].price > newPrice);
pixels[key].price = newPrice;
PixelPrice(row, col, pixels[key].owner, newPrice);
}
| 0 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| 1 |
function certificate(bytes32 email, bytes32 hash) ifOwner{
hashList[hash] = SignatureDetails({
email: email,
timeStamp: now
});
}
| 1 |
function totalSupply() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint balance);
function ownerOf(uint256 _tokenId) public constant returns (address owner);
function approve(address _to, uint256 _tokenId) public ;
function allowance(address _owner, address _spender) public constant returns (uint256 tokenId);
function transfer(address _to, uint256 _tokenId) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address _from, address _to, uint256 _tokenId);
event Approval(address _owner, address _approved, uint256 _tokenId);
}
contract ERC20 {
function totalSupply() public constant returns (uint256 _totalSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract VirtualGift is ERC721 {
string public name = "VirtualGift";
uint8 public decimals = 0;
string public symbol = "VTG";
string public version = "1.0";
address private defaultGiftOwner;
mapping(address => bool) allowPermission;
ERC20 private Gifto = ERC20(0x00C5bBaE50781Be1669306b9e001EFF57a2957b09d);
event Creation(address indexed _owner, uint256 indexed tokenId);
GiftToken[] giftStorageArry;
GiftTemplateToken[] giftTemplateStorageArry;
mapping(address => uint256) private balances;
mapping(uint256 => address) private giftIndexToOwners;
mapping(uint256 => bool) private giftExists;
mapping(address => mapping (address => uint256)) private ownerToApprovedAddsToGifIds;
mapping(uint256 => uint256[]) private giftTemplateIdToGiftids;
mapping(uint256 => uint256) private giftTypeToGiftLimit;
mapping(uint256 => uint256) private giftTypeToSelledSum;
struct GiftTemplateToken {
uint256 giftPrice;
uint256 giftLimit;
string giftImgUrl;
string giftName;
}
| 0 |
function LINKFund() {
min_buy_block = block.number + 3456;
min_refund_block = block.number + 864000;
}
| 0 |
function hdivide(uint256 x, uint256 y) constant internal returns (uint256 z) {
z = x / y;
}
| 0 |
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
revert();
}
}
else {
if(now < lock_addresses[_sender]) {
revert();
}
}
_;
}
| 1 |
function STTToken(address _owner, address _minter, address _wallet) payable {
owner = _owner;
minter = _minter;
wallet = _wallet;
balances[owner] = 0;
balances[minter] = 0;
balances[wallet] = 0;
balances[owner] = safeAdd(balances[owner], ownerInitialBalance);
StatsReserved = safeAdd(StatsReserved, ownerInitialBalance);
StatsTotal = safeAdd(StatsTotal, ownerInitialBalance);
Transfer(0, this, ownerInitialBalance);
Transfer(this, owner, ownerInitialBalance);
allowedTransfer[owner] = true;
allowedTransfer[minter] = true;
allowedTransfer[wallet] = true;
}
| 0 |
function balanceOf(address who) public view returns(uint);
function allowance(address owner, address spender) public view returns(uint);
function transfer(address to, uint value) public returns(bool ok);
function transferFrom(address from, address to, uint value) public returns(bool ok);
function approve(address spender, uint value) public returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.