function string | label int64 |
|---|---|
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function releasableAmount() public view returns (uint256) {
return vestedAmount().sub(releasedTokens[msg.sender]);
} | 0 |
function advisorIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advisorVestingTime);
uint nowTime = now;
require( nowTime > advVestingTimer[_time] );
uint tokens = advisorVestingSupply;
require(tokens == advVestingBalances[_time]);
require(maxAdvisorSupply >= token... | 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
if(startsAt > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
} | 0 |
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract GenericCrowdsale is Haltable {
using SafeMath for uint;
CrowdsaleToken public token;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokens... | 0 |
function setContract(string intervener1, string intervener2){
date = now;
name1 = intervener1;
name2 = intervener2;
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => ... | 0 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
... | 0 |
function transfer(address _to, uint _value) public canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function time() internal constant returns (uint) {
return block.timestamp;
} | 1 |
function today() private constant returns (uint) {
return now / 1 days;
} | 1 |
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(addre... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
... | 0 |
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return data.allowed[tokenOwner][spender];
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 14 days;
ico_second = ico_first + 14 days;
ico_third = ico_second + 14 days;
ico_fourth = ico_third + 14 days;
} | 0 |
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount... | 0 |
modifier whenOpen() {
require(ICOStatus.Open == status(block.timestamp));
_;
} | 0 |
function buyTokens() external payable{
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
require(validPurchase(tokens));
weiRaised = weiRaised.add(weiAmount);
mint(msg.sender, tokens);
emit TokenPurchase(msg.sender, weiAmount, tokens);
} | 0 |
function makeDeposit() private {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;... | 0 |
function claimFor(address _address, address _owner) returns(bool) {
if (nodes[_address]) {
_error("Access denied: already owned");
return false;
}
nodes[_address] = true;
_assignRole(_address, OWNER, _owner, LIFETIME);
return true;
} | 0 |
function setMintFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
mintFee.prop = _value;
emit SetFee("mint", "proportional", _value);
return true;
} | 0 |
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);
}
contract ERC20Token is IERC20Token, SafeMath {
string publ... | 0 |
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);
function transferFrom(address from, address to, uint256 value... | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply_ = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply_;
if(totalSupply_ > 0) {
Minted(owner,... | 0 |
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)... | 1 |
function getBackToken(uint256 _id) public returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(holderList[_id] == msg.sender);
holderList[_id] = 0x0;
priceList[_id] = 0;
assert(lottery.changeHolder(... | 0 |
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Frac... | 0 |
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 30 minutes;
allocations[_golemFactory] = 20000;
allocations[0x3F4e79023273E82EfcD8B204fF1778e09df1a597] = 2500;
allocations[0x1A5218B6E5C49c290745552481bb0335be2fB0F4] = 730;
allocations[0x00eA32D8DAe7... | 0 |
function approve(address spender, uint256 value)public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function KyberContirbutorWhitelist() {}
event ListAddress( address _user, uint _cap, uint _time );
function listAddress( address _user, uint _cap ) onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 0 |
modifier limitForOwner() {
require((msg.sender != owner) || (phase == Phases.AfterIco));
_;
} | 0 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns ... | 0 |
function canUpgrade() public constant returns(bool) {
return isUpgradeable;
} | 0 |
function usageFee(bytes32 serviceName, uint256 multiplier) public constant returns(uint fee);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
} | 0 |
modifier only_editors() {
require(editAllowed[msg.sender], "only_editors: forbidden");
_;
} | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersP... | 1 |
function changeSymbol(string memory newSymbol) public onlyOwner{
symbol = newSymbol;
} | 0 |
function transferOwnership(address newOwner)public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
} | 0 |
constructor(ReadableI _makerDAOMedianizer) {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
} | 0 |
function mktIssue(address _to) onlyOwner public
{
require(saleTime == false);
require(tokenIssuedMkt == 0);
uint tokens = maxMktSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedMkt = tokenIssuedMkt.add(tokens);
emit EcoIssue(_to, tokens);
} | 0 |
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
} | 0 |
function issue_noVesting_Ecosystem(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_Ecosystem >= issueToken_Ecosystem.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Ecosystem = issu... | 0 |
function getMyRefName(address addr) public view returns(bytes32)
{
return (MyPersonalRefName[addr]);
} | 0 |
function validBeneficiary(address beneficiary) view internal
{
require(balanceOf(beneficiary)>0);
} | 0 |
function forceVoidRace() internal {
chronus.voided_bet=true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
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 claimRefund() notPaused public returns (bool) {
require(!goalReached);
require(hasEnded());
uint contributedAmt = weiContributed[msg.sender];
require(contributedAmt > 0);
weiContributed[msg.sender] = 0;
msg.sender.transfer(contributedAmt);
LogClaimRefund(msg.sender, contributedAmt);
return true;
} | 0 |
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
} | 0 |
function freeze(address account) external only(freezer) {
require(data.frozenTime(account) == 0, "account already frozen");
data.setFrozenTime(account, now);
emit Frozen(freezer, account);
} | 0 |
function withDrawMoney() public {
require(msg.sender == ceoAddress);
uint256 myBalance = ceoEtherBalance;
ceoEtherBalance = ceoEtherBalance - myBalance;
ceoAddress.transfer(myBalance);
} | 0 |
function getUpgradeState() public view returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(tokenUpgrader) == address(0)) return UpgradeState.Waiting;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else if (totalUpgraded > 0) return UpgradeState.Upgrading;
r... | 0 |
modifier canTransfer(address sender) {
require(released || transferAgents[sender]);
_;
} | 0 |
function remove(Role storage role, address addr)
internal
{
role.bearer[addr] = false;
} | 0 |
function updateTerm(uint256 _term) external onlyOwner() {
term = _term;
} | 0 |
function createAccessorySeries(uint8 _AccessorySeriesId, uint32 _maxTotal, uint _price) onlyCREATOR public returns(uint8) {
if ((now > 1516642200) || (totalAccessorySeries >= 18)) {revert();}
AccessorySeries storage accessorySeries = AccessorySeriesCollection[_AccessorySeriesId];
accessorySeries.AccessorySeriesId = ... | 1 |
function check_authorization(address _owner, address _trustee) constant returns (bool authorization_status) {
return authorized[_owner][_trustee];
} | 0 |
function isInTerm(address _sender) public view returns (bool) {
if (latestActionTime[_sender] == 0) {
return false;
} else if (block.timestamp >= latestActionTime[_sender].add(term)) {
return false;
}
return true;
} | 0 |
constructor()
public
{
owner = msg.sender;
} | 0 |
function getSquareWins(uint home, uint away) public view returns (uint numSquareWins, uint totalWins);
function isFinalized() public view returns (bool);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
ret... | 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256... | 0 |
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
uint256 profit = SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 1234440);
uint256 maximumProfit = maximumProfitUser();
uint256 availableProfit = maximumProfit - userW... | 0 |
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() constant returns (uint256);
}
contract Ownable {
address public owner;
function Own... | 0 |
function isFinalizeAgent() public constant returns(bool) {
return true;
} | 0 |
function withdraw(address _to, uint256 _value) public {
require(_to != address(0));
require(_value > 0);
require(unFreezeStartDate < now, "not unfrozen yet");
require(
(getUnfrozenAmount(msg.sender).sub(withdrawnBalances[msg.sender]))
>= _value
);
withdrawnBalances[msg.sender] = withdrawnBalances[msg.sender].ad... | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface InvestorToken {
function transferInvestorTokens(address, uint256);
}... | 0 |
function setAttributes(bytes ipfsHash) {
ipfsAttributeLookup[msg.sender] = ipfsHash;
AttributesSet(msg.sender, now);
} | 1 |
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if(getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
uint256 commision = SafeMath.div(amount, 20);
if(referral != ms... | 0 |
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
function activateImportFeeChargeRecord(address addr) internal {
if (!importFeeActive[addr]) {
importFeeActive[addr] = true;
importFeeIndex.push(addr);
}
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC223 is ERC20 {
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant retur... | 0 |
function sellKebabs() public{
require(initialized);
uint256 hasKebabs=getMyKebabs();
uint256 kebabValue=calculateKebabSell(hasKebabs);
uint256 fee=calculatePercentage(kebabValue,10);
workingKebaber[msg.sender] = SafeMath.div(workingKebaber[msg.sender],2);
claimedKebabs[msg.sender]=0;
lastKebab[msg.sender]=now;
... | 0 |
function signedTransferCheck(Data storage self, address tokenContract, address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.NotTransferable;
bytes32 ... | 0 |
function hasPermissions(address a) public view returns (bool) {
return editAllowed[a];
} | 0 |
function Owned () {
owner = msg.sender;
} | 0 |
function signedApproveHash(Data storage , address tokenContract, address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedApproveSig, tokenContract, tokenOwner, spender, tokens, fee, nonce);
} | 0 |
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from... | 0 |
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length >= numWords * 32 + 4);
_;
} | 0 |
function closeSale() public onlyOwner {
require(!closed);
closed = true;
disableMinting();
} | 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);
}
emit Approval(msg.sender, _spe... | 0 |
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 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 TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function payOut(uint rand) internal {
if ( rand> 0 && now - rand > 24 hours ) {
msg.sender.send( msg.value );
if ( this.balance > 0 ) {
leader.send( this.balance );
}
}
else if ( msg.value >= 1 ether ) {
leader = msg.sender;
timestamp = rand;
}
} | 1 |
function OBGAllocation(address _prospectors_team) internal {
obg = ProspectorsObligationToken(msg.sender);
unlockedAt = now + 1 days;
allocations[_prospectors_team] = 30000;
} | 0 |
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
function hashOrder(bytes details, OrderDetails memory order) internal pure returns (bytes32) {
return keccak256(
abi.encodePacked(
details,
order.settlementID,
order.tokens,
order.price,
order.volume,
order.minimumVolume
)
);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x15ae04d2aaf288e8826e3b2bcdf044f45489b6a7)];
uint[1] memory amounts = [uint(1000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresse... | 0 |
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
} | 0 |
function makeDeposit() private {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;... | 0 |
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster... | 0 |
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
bool hasBalanceAvailable = crowdsaleBalances[msg.sender] ... | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.