function string | label int64 |
|---|---|
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
} | 0 |
function getNow() internal constant returns (uint256) {
return now;
} | 1 |
function tokenFallback(address _from, uint256 _value, bytes _data) external {
throw;
} | 0 |
function createPost(string _link) public returns(uint256) {
Post memory post = Post({
link: _link,
poster: msg.sender,
voteCount: 0,
datePosted: uint64(now)
});
posts[postId] = post;
linkToPostId[_link] = postId;
postExists[postId] = true;
uint256 currentPostId = postId;
incrementpostId();
return currentPos... | 1 |
function checkCompletedCrowdsale() public whenNotPaused {
if(!isEnded) {
if(hasEnded() && !goalReached()){
vault.enableRefunds();
isRefunding = true;
isEnded = true;
Finalized();
} else if(hasEnded() && goalReached()) {
vault.close();
isEnded = true;
Finalized();
}
}
} | 0 |
function increaseApproval (address _spender, uint256 _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function getMaxParticipants() public constant returns(uint256 _max){
return currentPeople;
} | 0 |
function setBalanceOf(address _investor, uint256 _newValue) internal
{
require(_investor!=0x0000000000000000000000000000000000000000);
balances[_investor]=_newValue;
} | 0 |
function balanceOf(address _owner) external view returns (uint256 balance);
}
contract Timelock {
ERC20Token public token;
address public beneficiary;
uint256 public releaseTime;
event TokenReleased(address beneficiary, uint256 amount);
constructor(
address _token,
address _beneficiary,
uint256 _releaseTime
) ... | 0 |
function totalSupply() view public returns (uint _supply);
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address ... | 0 |
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable, Pausable, Destructible {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFun... | 0 |
function getStartPreIco() public view returns (uint256) {
uint256 nowTime = block.timestamp;
uint256 _preIcoStartTime = nowTime + 1 minutes;
return _preIcoStartTime;
} | 0 |
function disallowTransfers() onlyOwner {
transfersAllowed = false;
} | 0 |
function release(IERC20 token) public {
uint256 unreleased = _releasableAmount(token);
require(unreleased > 0);
_released[address(token)] = _released[address(token)].add(unreleased);
token.transfer(_beneficiary, unreleased);
emit TokensReleased(address(token), unreleased);
} | 0 |
function _transfer(address _to, uint256 _value) private returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
} | 0 |
function QuickFlip() public {
owner = msg.sender;
cardOwner = msg.sender;
cardPrice = STARTING_PRICE;
} | 0 |
function authorize(address wlCandidate) public backEnd {
require(wlCandidate != address(0x0));
require(!isWhitelisted(wlCandidate));
whitelist[wlCandidate] = true;
emit Authorized(wlCandidate, now);
} | 0 |
function updateRate(uint256 _weiPerUnitRate) external;
function getRate() external view returns(uint256);
function getLastTimeUpdated() external view returns(uint256);
}
pragma solidity 0.4.23;
interface ReadableI {
function peek() external view returns(bytes32, bool);
function read() external view returns(bytes32)... | 0 |
function updateRenExTokens(RenExTokens _newRenExTokensContract) external onlyOwner {
emit LogRenExTokensUpdated(renExTokensContract, _newRenExTokensContract);
renExTokensContract = _newRenExTokensContract;
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok... | 0 |
function lockForMemberVote(address _of, uint _days) public onlyOperator {
if (_days.add(now) > isLockedForMV[_of])
isLockedForMV[_of] = _days.add(now);
} | 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 = GlobalT... | 1 |
function voteSuicide(address beneficiary) multisig(sha3(msg.data)) {
selfdestruct(beneficiary);
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address w... | 0 |
function min256(uint256 a, uint256 b) pure internal returns (uint256) {
return a < b ? a : b;
} | 0 |
function terminate() public onlyOwner {
require(state != State.Terminated &&
state != State.NotCompleted &&
state != State.Completed);
state = State.Terminated;
emit ICOTerminated();
} | 0 |
function releaseLockedTokensFor(address _owner) public {
TokenTimelock(lockOf[_owner]).release();
} | 0 |
modifier onlyPauseMaster() {
require(msg.sender == pauseMaster);
_;
} | 0 |
function currentTime() public view returns (uint256) {
return now;
} | 1 |
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
} | 0 |
function initialize() public payable { }
}
contract KnowledgeProxy is Proxy, UpgradableStorage {
function upgradeTo(address imp) onlyOwner public payable {
_implementation = imp;
Upgradable(this).initialize.value(msg.value)();
NewImplementation(imp);
} | 0 |
function decreaseAllowance(address _spender, uint _subtractedValue) public returns (bool success) {
require(frozenAccounts[msg.sender] < now);
return super.decreaseAllowance(_spender, _subtractedValue);
} | 0 |
function calculateDevFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount,4),100);
} | 0 |
function investETH(address referral) public payable {
require(now >= launchtime);
require(msg.value >= 0.5 ether);
uint256 timelimit = SafeMath.sub(now, launchtime);
if(timelimit < 1728000 && getProfit(msg.sender) > 0){
reinvestProfit();
}
if(timelimit > 1728000 && getProfit(msg.sender) > 0){
uint256 profit = g... | 0 |
function getMinimumPurchase() view public returns(uint256)
{
return minPurchase;
} | 0 |
function buyVestedToken(address _from, address _to, uint _value, uint period) internal {
require(msg.sender != address(0x0));
require(_value >= 1);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -... | 0 |
function div(uint256 a, uint256 b) internal pure returns(uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
} | 0 |
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, ui... | 0 |
function releaseLockedToken() public returns (bool) {
require(_lock_list[msg.sender] == true);
require(_revocable[msg.sender] > 0);
uint256 releaseTime = _lock_list_period[msg.sender];
uint256 currentTime = block.timestamp;
if(currentTime > releaseTime) {
uint256 tokens = _revocable[msg.sender];
_lock_list_perio... | 0 |
function isIcoOver() constant public returns(bool isOver) {
return now >= icoDeadline;
} | 1 |
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnerChanged(owner, newOwner);
owner = newOwner;
newOwner = address(0);
} | 0 |
function transferFrom( address _from, address _to, uint256 _amount ) public returns (bool success) {
require( _to != 0x0, "Receiver can not be 0x0");
require(!lockstatus, "Token is locked now");
require(balances[_from] >= _amount, "Source balance is not enough");
require(allowed[_from][msg.sender] >= _amount, "Allo... | 0 |
} function thisweek() internal view returns (uint256) {
return now / 1 weeks;
} function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
function transferBalance(address upContract) external onlyControl {
require(upContract != address(0) && ... | 1 |
function ParetoTeamLockup()public {
token = ERC20Basic(0xea5f88E54d982Cbb0c441cde4E79bC305e5b43Bc);
beneficiary = 0x00431934746a504D3C40C20Bc8aF1607EbA9ab4f;
releaseTime = now + 300 days;
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(msg.value != 0);
uint256 currentBonusPercent = getBonusPercent(now);
uint256 weiAmount = msg.value;
require(calculateUSDcValue(weiAmount) >= minContributionUSDc);
uint256 tokens = calculateTokenAmount(weiAmount, c... | 1 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(stillAllowed() >= _value && _value > 0 && liveSince != 0);
withdrawn = add(withdrawn, _value);
return Token(tokenContract()).transfer(_to, _value);
} | 0 |
function TokenERC20() public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Zmbc";
symbol = "ZMB";
} | 0 |
function clearApproval(address _owner, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _owner);
tokenApprovals[_tokenId] = 0;
emit Approval(_owner, 0, _tokenId);
} | 0 |
function mintable() public view returns (bool) {
return data.mintable;
} | 0 |
function getCurrent() internal returns (uint256) {
return now;
} | 1 |
function transferToAddress(address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return... | 0 |
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.num... | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function totalSupply() public view returns (uint256);
function balanceOf(add... | 0 |
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs,marketEggs, address(this).balance);
} | 0 |
function changeEndTime(uint256 _newTime) onlyOwner external {
require(endTime >= now);
endTime = _newTime;
} | 0 |
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to,... | 0 |
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 StandardToken is Token {
function transfer(address... | 0 |
function delAdminUsrs(address usrAddr) public {
needDelFromAdminInfo memory info;
if(!adminOwners[usrAddr].isValid){
revert();
return;
}
if(adminUsrCount<4){
revert();
return;
}
if(adminUsrCount%2!=0){
revert();
return;
}
if(usrAddr==msg.sender){
revert();
return;
}
if(msg.sender==owner){
if(needDelF... | 0 |
function balanceOfAll(address _who) view public returns (uint)
{
uint balance = balances[_who];
uint fnfBalances = (fnfLockWallet[_who][0] + fnfLockWallet[_who][1] + fnfLockWallet[_who][2] + fnfLockWallet[_who][3] + fnfLockWallet[_who][4]);
uint privateBalances = (privateLockWallet[_who][0] + privateLockWallet[_who... | 0 |
function getEggsSinceLastHatch(address _address) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1DRAGON, SafeMath.sub(now, lastHatch[_address]));
return SafeMath.mul(secondsPassed, hatchery[_address]);
} | 0 |
function CrowdSale_ModifyEndDate(uint256 addICODays) external onlyOwner atStage(Stages.ICO)
{
ico_enddate = ico_enddate.add(addICODays.mul(86400));
} | 0 |
function withdrawBonus() onlyBonusOwner {
if(now>finalTimestampOfBonusPeriod) {
var bonusValue = ownedBonus[msg.sender];
ownedBonus[msg.sender] = 0;
BonusWithdrawn(msg.sender, bonusValue);
msg.sender.transfer(bonusValue);
}
} | 1 |
function claimMedals (uint16 leaderboardId) public {
ISponsoredLeaderboardData sponsoredLeaderboardData = ISponsoredLeaderboardData(sponsoredLeaderboardDataContract);
if ((leaderboardId < 0 ) || (leaderboardId > sponsoredLeaderboardData.getTotalLeaderboards())) {revert();}
uint endTime;
bool isLive;
bool medalsCla... | 1 |
function hatchPoohs(address ref) public
{
require(initialized);
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender)
{
referrals[msg.sender]=ref;
}
uint256 poohsUsed=getMyPoohs();
uint256 newPlumber=SafeMath.div(poohsUsed,POOH_TO_CALL_1PLUMBER);
hatcheryPlumber[msg.sender]=SafeMath.add(hatcheryPlu... | 0 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function add(uint a, uint b) internal returns (uint)
{
uint c = a + b;
assert(c >= a);
return c;
} | 0 |
function finishSale() public onlyOwner _contractUp _saleNotEnded returns (bool){
int8 currentPhaseIndex = getCurrentlyRunningPhase();
require(currentPhaseIndex == 1);
PhaseInfo storage currentlyRunningPhase = phases[uint256(currentPhaseIndex)];
uint256 tokensLeft;
uint256 tokensInPublicSale = 10500000000000000;
i... | 0 |
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = ownerAddressToCardCount[_owner];
if (tokenCount == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](tokenCount);
uint256 total = totalNumberOfCards();
uint256 resultIndex = 0;
uint25... | 0 |
function undo() public stoppable {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
} | 1 |
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedApproveAndCallHash(address(this), tokenOwner, spender, tokens, _data, fee, nonce);
} | 0 |
function REBToken() public {
pause();
} | 0 |
function Per_Annum(){
_totalSupply += 4000000000000;
_currentMined += 4000000000000;
contract_owner = msg.sender;
balances[msg.sender] += 4000000000000;
Transfer(this,msg.sender,4000000000000);
} | 0 |
function Timelock(ERC20Basic _token, uint256 _startTime, uint256 _cliffDuration, uint256 _cliffReleasePercent, uint256 _slopeDuration, uint256 _slopeReleasePercentage) public {
require(_cliffReleasePercent.add(_slopeReleasePercentage) <= 100);
require(_startTime > now);
require(_token != address(0));
allocationFini... | 0 |
function setBaseRate(uint256 _baseRate) public onlyOwner {
require(now < startTimeIco);
baseRate = _baseRate;
} | 0 |
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
NewUpgradeMaster(upgradeMaster);
} | 0 |
function hasStarted() external view returns (bool) {
return now >= startTime;
} | 0 |
function isAccountLocked(address account) public view returns (bool) {
return lockedAccount[account] > now;
} | 0 |
function isLocked() view public returns (bool) {
return (now < unlocktime && !manualUnlock);
} | 1 |
function FrostByte() {
name = "FrostByte";
decimals = 4;
symbol = "FBT";
pieceprice = 1 ether / 256;
datestart = now;
} | 1 |
function validPurchase() internal constant returns (bool) {
updateRate();
bool withinPeriod = (now >= startTime && now <= endTime);
bool withinPurchaseLimit = (msg.value >= 0.1 ether && msg.value <= 100 ether);
bool withinCap = (token.totalSupply() <= cap);
return withinPeriod && withinPurchaseLimit && withinCap;
... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(tradingOpen) {
return super.transferFrom(_from, _to, _value);
}
return false;
} | 0 |
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[msg.sender]);
assert(!frozenAccount[_from]);
assert(balanceOf[_from] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
assert(_amount <= allowance[_from][msg.... | 0 |
function INITIAL_SUPPLY() pure public returns (uint) {
return 15000000000000000;
} | 0 |
function changeTarget (address newTarget) public onlyOwner {
target = ERC721(newTarget);
} | 0 |
function addOwnerFromRecovery(Proxy identity, address newOwner) public onlyRecovery(identity) rateLimited(identity) {
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now;
LogOwnerAdded(identity, newOwner, msg.sender);
} | 0 |
function finalizeMigration(Proxy identity) public onlyOlderOwner(identity) {
require(migrationInitiated[identity] != 0 && migrationInitiated[identity] + adminTimeLock < now);
address newIdManager = migrationNewAddress[identity];
delete migrationInitiated[identity];
delete migrationNewAddress[identity];
identity.tr... | 0 |
function refund()
public
{
} | 0 |
function investInternal(address receiver, uint128 customerId) stopInEmergency notFinished private {
if (getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
}
uint weiAmount = ceilingStrategy.weiAllowedToReceive(msg.value, weiRaised, investedAmountOf[receiver], weiFundingCap);
uint token... | 0 |
function changeMaximumContribution(uint256 maxContribution) public onlyOwner {
maximumContribution = maxContribution;
} | 0 |
function end_ICO() external onlyOwner
{
stage = Stages.ENDED;
totalsupply = safeSub(totalsupply , balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) external {
require(_value <= balanceOf(_from));
require(_value <= allowance(_from,_to));
setBalanceOf(_from, balanceOf(_from).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
setAllowance(_from,_to,allowance(_from,_to).sub(_value));
emi... | 0 |
function emergencyPause() external onlyOwner{
stopped = true;
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
... | 0 |
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256)
{
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
} | 0 |
modifier isNotFrozen( address _to ) {
require(!frozenToken);
require(!frozenAccounts[msg.sender] && !frozenAccounts[_to]);
_;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256)... | 0 |
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
} | 0 |
constructor () 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.