function string | label int64 |
|---|---|
modifier changesToVestingNotFreezed(address adr) {
require(!vestingMap[adr].changeFreezed);
_;
} | 0 |
function newOPESTA(bytes32 client_full, bytes32 address_full, bytes32 pro, address declared_for, uint nature_bon, uint status, bytes32 reference_interne, bytes32 fiche, uint volumekWh, uint date_engagement, uint date_facture) public {
emit OPESTA(client_full, address_full, pro, msg.sender, declared_for, nature_bon, st... | 0 |
function updateUpdater(address newUpdater) onlyOwner {
updater = newUpdater;
} | 0 |
function fetch(address player)
private
{
Bet storage bet = bets[player];
require(bet.blocknumber < block.number);
bet.isOpen = false;
if(block.number - 256 > bet.blocknumber) {
emit Expiration(player, bet.amount);
return;
}
uint256 roll = (uint256(blockhash(bet.blocknumber)) % 100) + 1;
if(roll <= bet.chance... | 0 |
function cancel () noEther onlyOwner {
suicide(owner);
} | 0 |
function createProxyAddress() public returns (address) {
address proxy = new CrowdsaleProxy(msg.sender, targetCrowdsale);
ProxyCreated(proxy, msg.sender);
return proxy;
} | 0 |
function tokensPerWeiPlusBonus(uint _per) public view returns (uint) {
return defaultTokensPerWei.add(
amountPercentage(defaultTokensPerWei, _per)
);
} | 0 |
function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) {
require(_x >= _y);
return _x - _y;
} | 0 |
function closeStageOne() public onlyOwner beforeStageOneClosed {
stageOneClosed = true;
} | 0 |
function setPayTo(address) external;
function getPayTo() external view returns (address) {
return _getPayTo();
} | 0 |
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
} | 0 |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(getRate());
} | 0 |
function triggerCrossFork(string _btcAddress) isCrossForking public returns(ForkResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
if (crossForkIds[_btcAddress] > 0) {
LogTriggerCrossFork(btcAddressHash, crossForkIds[_btcAddress], ForkResultCode.RECEIVED);
return ForkResultCode.RECEIVED;
}
crossForkCo... | 1 |
function transferToTeam(address _team) external onlyOwner returns(bool) {
require(_team != address(0), "Address is not valid");
require(!teamRelease, "Team release has already done");
if (now > contractDeployed.add(365 days) && team_1_release == false) {
balances[_team] = balances[_team].add(_teamLockedTokens);
te... | 0 |
function unlock(address _tokenAddr, address[] dests, uint256[] values)
onlyOwner
returns (uint256) {
bool itsTime=false;
if ( now >=1537531200 )
itsTime=true;
require(itsTime);
uint256 i = 0;
while (i < dests.length) {
StandardToken(_tokenAddr).transfer(dests[i], values[i]);
i += 1;
}
return(i);
} | 1 |
function getOwner() view internal returns(address)
{
return owner;
} | 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 activateInvoiced(address addr) internal {
if (!invoicedActive[addr]) {
invoicedActive[addr] = true;
invoicedIndex.push(addr);
}
} | 0 |
function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool) {
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address ... | 0 |
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(
c / a == b,
"UINT256_OVERFLOW"
);
return c;
} | 0 |
modifier isOperational() {
assert(isFinalized);
_;
} | 0 |
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
} | 0 |
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
} | 0 |
function powerPool() constant returns (uint256);
function totalSupply() constant returns (uint256);
function allowance(address _owner, address _spender) constant returns (uint256);
function approve(address _owner, address _spender, uint256 _amountBabz) public;
function transfer(address _from, address _to, uint256 _... | 0 |
function canSelfDestruct()
public
view
returns (bool)
{
if (isLiquidating()) {
bool totalPeriodElapsed = liquidationTimestamp + liquidationPeriod < now;
bool allTokensReturned = (liquidationTimestamp + 1 weeks < now) && (totalSupply == 0);
return totalPeriodElapsed || allTokensReturned;
}
return false;
} | 0 |
function transfer(address _to, uint256 _tokens) public returns(bool resultTransfer);
function transferFrom(address _from, address _to, uint256 _tokens) public returns(bool resultTransfer);
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) cons... | 0 |
function setUpgradeAgent(address agent) external {
require(canUpgrade());
require(agent != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSu... | 0 |
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
} | 0 |
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}
eve... | 0 |
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract Owned {
address public owner;
function Owned () public {
owner = msg.sender;
} | 0 |
function getMedian(uint a, uint b, uint c) internal pure returns (uint) {
if (a.gt(b) ^ c.gt(a) == 0x0) {
return a;
} else if(b.gt(a) ^ c.gt(b) == 0x0) {
return b;
} else {
return c;
}
} | 0 |
function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )returns (address){}
function transfer ( address _address , uint256 amount ){}
function share()returns(uint256){}
function totalSupply()returns(uint256){}
function initialSupply()returns(uint256){... | 0 |
function setTiersInfo(uint8 _noOfPhases, uint256[] _startTimes, uint256[] _endTimes, uint256[] _hardCaps ,uint256[] _minEtherContribution, uint8[2] _bonusPercentages)private {
require(_noOfPhases == 2);
require(_startTimes.length == 2);
require(_endTimes.length == _noOfPhases);
require(_hardCaps.length == _noOfPhas... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _... | 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 |
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken { function S... | 0 |
function times(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
} | 1 |
function setTokenUnlock() onlyOwner_manager public
{
require(tokenLock == true);
require(saleTime == false);
tokenLock = false;
} | 0 |
function startAuction() public isOwner atStage(Stages.AuctionSetUp) {
stage = Stages.AuctionStarted;
startTime = now;
startBlock = block.number;
AuctionStarted(startTime, startBlock);
} | 0 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 0 |
function TruUpgradeableToken(address _upgradeMaster) public {
require(_upgradeMaster != address(0));
upgradeMaster = _upgradeMaster;
} | 0 |
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResul... | 0 |
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint))... | 0 |
function approve(address spender, uint value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.approve(spender, value);
} | 0 |
function transfer(address _to, uint256 _value) public limitedDaily(_value) returns (bool) {
require(_to != address(0));
require(_to != msg.sender);
totalSupply_ += _value;
balances_[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function init(address _token, address _whitelist) public onlyOwner {
require(_token != address(0) && _whitelist != address(0));
require(token == address(0) && whitelist == address(0));
require(Ownable(_token).owner() == address(this));
token = GiftToken(_token);
whitelist = Whitelist(_whitelist);
unpause();
} | 0 |
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
} | 0 |
function transferAndFreezing(address _to, uint256 _value, uint256 freeze_amount, uint end_stamp, uint8 freezing_type) auth stoppable public returns (bool) {
require(_value < c_totalSupply);
require(freeze_amount <= _value);
transfer(_to, _value);
setFreezing(_to, end_stamp, freeze_amount, freezing_type);
return tr... | 0 |
function setMinter(Data storage self, address minter) public {
require(msg.sender == self.owner);
require(self.mintable);
MinterUpdated(self.minter, minter);
self.minter = minter;
} | 0 |
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval... | 0 |
function ecoIssue(address _to, uint _time, uint _value) onlyOwner public
{
require(saleTime == false);
require( _time < ecoVestingTime);
uint nowTime = now;
require( nowTime > ecoVestingTimer[_time] );
uint tokens = _value * E18;
require(tokens <= ecoVestingBalances[_time]);
require(tokens > 0);
require(maxEco... | 0 |
function checkPermissions(address from) internal constant returns (bool) {
if (from == company && now < unlockTime) {
return false;
}
if (from == crowdsale) {
return true;
}
return true;
} | 0 |
function migrateAuction(uint _auctionId, address _newAuction) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).approve(_ne... | 0 |
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external retu... | 0 |
constructor( address _registry, uint256 _totalTokenAmount ) public
{
_mint(_registry, _totalTokenAmount);
addSuperAdmin(_registry);
} | 0 |
function approve(address _spender, uint256 _value)
whenNotPaused limitForOwner public returns (bool success)
{
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
return super.approve(_spender, _value);
} | 0 |
function buy() payable public {
uint amount = msg.value * buyPrice;
_transfer(this, msg.sender, amount);
} | 0 |
function vest()
external
{
uint total;
for (uint i = 0; i < numVestingEntries(msg.sender); i++) {
uint time = getVestingTime(msg.sender, i);
if (time > now) {
break;
}
uint qty = getVestingQuantity(msg.sender, i);
if (qty == 0) {
continue;
}
vestingSchedules[msg.sender][i] = [0, 0];
total = safeAdd(total,... | 0 |
function transfer(address _to, uint256 _value) returns (bool success){
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function transferFrom(address from, address to, uint value) public returns(bool ok);
function approve(address spender, uint value) public returns(bool ok);
function transfer(address to, uint value) public returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address ... | 0 |
function transfer(address _to, uint256 _value) returns (bool success)
{
if ((balanceOf[msg.sender] < _value) || (balanceOf[_to] + _value < balanceOf[_to]) || (frozenAccount[msg.sender]) || (frozenAccount[_to]))
{
return false;
}
else
{
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.se... | 0 |
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 cancelSeller(bytes32 _hashDeal, uint256 _additionalGas)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.cancelTime > block.timestamp)
return false;
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_RELEASE;
bool r... | 0 |
function shutDownUnlocked() public isOwer() {
activated_ = false;
} | 0 |
function myTokens()
external
view
returns(uint256)
{
return shareholders[msg.sender].tokens;
} | 0 |
function pay(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
payable
{
require(msg.value > 0);
require(msg.value == _value);
require(msg.value > _commission);
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, msg.value, _commission);
verifyDea... | 0 |
function setGod(address _newGod) external requireGod {
require(_newGod != address(0));
godAddress = _newGod;
} | 0 |
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address ... | 0 |
function allowance(address _owner, address _spender) 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 AirSwapExchange {
mapping (bytes32 => bool) public fills;... | 1 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
} | 0 |
function myHoldAgeTimestamp() external view returns (uint256) {
return _holdAgeTimestamp(msg.sender);
} | 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);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
eve... | 0 |
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address ... | 0 |
function ownerWithdrawUnspentCredits() external onlyOwner {
require(now >= PRESALE_END_DATE);
require(now < TOKEN_WITHDRAWAL_START_DATE);
require(totalFunding >= PRESALE_MINIMUM_FUNDING);
require(!unspentCreditsWithdrawn);
uint256 currentCredits = parsecToken.balanceOf(this);
uint256 unspentAmount = currentCredit... | 0 |
function mint(address _to, string _identity) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
if (ownedToken[_to] != 0x0) return false;
bytes32 id = TokenLib.generateId(_identity);
var token = tokens[id];
if (id == token.id()) return false;
token.owner = _to;
toke... | 0 |
function burnToken(uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenSupply = burnTokenSupply.add(tokens);
totalTokenSupply = totalTokenSupply.sub(tokens);
emit Burn(msg.sender, tokens);
emit Tra... | 0 |
modifier onlyExpiredSwaps(bytes32 _swapID) {
require (now >= swaps[_swapID].timelock);
_;
} | 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 buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
send... | 1 |
function getCurrentTimestamp() internal returns (uint256) {
return now;
} | 1 |
constructor(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function canUpgrade() public view returns(bool) {
return released;
} | 0 |
function setDefaultParamsIfNeeded() internal {
if (bounty == address(0)) {
bounty = owner;
}
if (upgradeMaster == address(0)) {
upgradeMaster = owner;
}
if (pauseMaster == address(0)) {
pauseMaster = owner;
}
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _w... | 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (u... | 0 |
function finalize() onlyOwner external {
require(!isFinalized);
endTime = now;
isFinalized = true;
emit Finalized();
} | 0 |
function deposit(uint _value, uint _forTime) public payable returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
balances[msg.sender] = balances[msg.sender].add(msg.value);
totalSupply_ = totalSupply_.add(msg.value);
depositLock[msg.sender] = now + _forTime... | 0 |
function addTeamAndAdvisorsAllocation(address teamOrAdvisorsAddress, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(teamAndAdvisorsAllocations[teamOrAdvisorsAddress] == 0);
teamAndAdvisorsAllocations[teamOrAdvisorsAddress] = allocationValue;
return true;
} | 0 |
function participantWithdrawIfMinimumFundingNotReached(uint256 value) external {
require(now >= PRESALE_END_DATE);
require(totalFunding < PRESALE_MINIMUM_FUNDING);
uint256 senderBalance = balanceOf[msg.sender];
require(senderBalance >= value);
balanceOf[msg.sender] = senderBalance.sub(value);
msg.sender.transfer(... | 0 |
function max64(uint64 a, uint64 b) pure internal returns (uint64) {
return a >= b ? a : b;
} | 0 |
function updateVIPRank(address _to) returns (uint256 rank) {
if (balances[_to] >= VIP_MINIMUM && viprank[_to] == 0) {
viprank[_to] = now;
vips.push(_to);
}
return viprank[_to];
} | 1 |
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
} | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
} | 0 |
function cancelSellOrder(SellOrder order) noEther onlyDaoChallenge {
uint256 tokens = order.tokens();
tokenBalance += tokens;
order.cancel();
} | 0 |
function transfer(address _to, uint _tokens) public afterFrozenDeadline returns (bool success) {
require(now > frozenAccountByOwner[msg.sender]);
balances[msg.sender] = safeSub(balances[msg.sender], _tokens);
balances[_to] = safeAdd(balances[_to], _tokens);
emit Transfer(msg.sender, _to, _tokens);
return true;
} | 0 |
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) ... | 0 |
function getEndIco() public view returns (uint256) {
uint256 _icoEndTime = 1551416400;
return _icoEndTime;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.