function string | label int64 |
|---|---|
function upgradeFrom(address _from, uint256 _value) public {}
}
contract UpgradeableToken is MintableAndPausableToken {
address public upgradeMaster;
bool private upgradesAllowed;
TokenUpgrader public tokenUpgrader;
uint public totalUpgraded;
enum UpgradeState { Unknown, NotAllowed, Waiting, ReadyToUpgrade, Upgrad... | 0 |
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
return SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 345600);
} | 0 |
function StopICO() external onlyOwner {
stopped = true;
stage = Stages.PAUSED;
} | 0 |
modifier addressNotRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor == address(0));
_;
} | 0 |
function saleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
pbIssuedSale = pbIssuedSale... | 0 |
function refundSubmission(address _refundee, uint256 _amount) external onlyAdmin() {
submissionPool = submissionPool.sub(_amount);
_refundee.transfer(_amount);
endingBalance = address(this).balance;
} | 0 |
function changeOperator(address _newOperator) public onlyOperator returns (bool) {
operator = _newOperator;
return true;
} | 0 |
function ecrecoverFromSig(Data storage , bytes32 hash, bytes sig) public pure returns (address recoveredAddress) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) return address(0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}... | 0 |
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
} | 0 |
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
b... | 0 |
function hasEnded() public view returns (bool) {
return now > endTime;
} | 0 |
function __redeemAmount(address investor) internal view returns (uint amount) {
uint allowance = token.allowance(investor, this) / k;
uint balance = balances[investor];
return balance < allowance ? balance : allowance;
} | 0 |
modifier onlyUpgradeMaster() {
require(msg.sender == upgradeMaster);
_;
} | 0 |
function getCurrentContextAddress()
internal
view
returns (address);
}
contract MWrapperFunctions is
IWrapperFunctions
{
function fillOrKillOrderInternal(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
internal
returns (LibFillResults.FillResults memory fillResults);
}
co... | 0 |
modifier whenPaused() {
require(paused);
_;
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
function setaddrFWD(address _value) public onlyOwner{
addrFWD=_value;
} | 0 |
function unlock() external {
if (now < unlockedAt) throw;
if (tokensCreated == 0)
tokensCreated = obg.balanceOf(this);
var allocation = allocations[msg.sender];
allocations[msg.sender] = 0;
var toTransfer = tokensCreated * allocation / totalAllocations;
if (!obg.transfer(msg.sender, toTransfer)) throw;
} | 0 |
function random(uint64 upper) public returns (uint64 randomNumber) {
_seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
return _seed % upper;
} | 1 |
function startTournament() onlyOwner nonReentrant external {
require(participants.length == maxParticipantCount);
_firstRoundFight();
_secondRoundWinnersFight();
_secondRoundLosersFight();
_finalRoundWinnersFight();
_finalRoundLosersFight();
uint winnerRewards = tournamentRewards * winPercent / 100;
uint loserR... | 1 |
function isContractPermanent(string _name) view public returns (bool) {
return contracts[_name].isPermanent;
} | 0 |
function withdrawCommunityPart(address _to) public onlyManager() {
require(now > nextWithdrawDayCommunity);
uint _value;
if (withdrawedCoummunityCounter == 0) {
_value = communityReservation / 2;
} else if (withdrawedCoummunityCounter == 1) {
_value = communityReservation * 3 / 10;
} else if (withdrawedCoummunit... | 0 |
function currentWindow() public constant returns (uint) {
return windowAt(block.timestamp);
} | 1 |
modifier onlyActiveAuction() {
require(isActiveAuction(), "Auction not active");
_;
} | 0 |
function hasEnded() public view returns (bool) {
return now > endTime;
} | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable) public
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(ow... | 0 |
function getNextPrice(bytes32 democHash) external view returns (uint);
function noteBallotDeployed(bytes32 democHash) external;
function upgradeMe(address newSC) external;
}
contract safeSend {
bool private txMutex3847834;
function doSafeSend(address toAddr, uint amount) internal {
doSafeSendWData(toAddr, "", amou... | 0 |
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
} | 0 |
function max64(uint64 a, uint64 b)
internal
pure
returns (uint256)
{
return a >= b ? a : b;
} | 0 |
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _p... | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByH... | 0 |
function initialize() public {
require(address(token) == 0);
token = ERC20(msg.sender);
} | 1 |
function timeunlockAccount(address target) public onlyOwner {
timelockAccounts[target] = now;
emit TimeLockFunds(target, now);
} | 0 |
function receiveTokens(uint256 tokens) {
DaoAccount sender = DaoAccount(msg.sender);
if (!AbstractDaoChallenge(daoChallenge).isMember(sender, sender.getOwnerAddress())) throw;
if (tokens > sender.getTokenBalance()) throw;
if (tokenBalance + tokens < tokenBalance) throw;
tokenBalance += tokens;
} | 0 |
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
requ... | 0 |
function weiAllowedToReceive(uint weiAmount, address customer) internal constant returns (uint weiAllowed);
function calculatePrice(uint weiAmount, address customer) internal constant returns (uint tokenAmount);
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner notFinished {
req... | 0 |
function closeStageTwo() public onlyOwner afterStageOneClosed {
stageTwoClosed = true;
} | 0 |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
} | 0 |
function forwardFunds() internal {
owner.transfer(msg.value);
} | 0 |
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emi... | 0 |
constructor ()
public
{
EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
keccak256(bytes(EIP712_DOMAIN_NAME)),
keccak256(bytes(EIP712_DOMAIN_VERSION)),
bytes32(address(this))
));
} | 0 |
function symbol() public constant returns (string) {
return symbol;
} | 0 |
function finishMinting() external onlyMinter returns (bool) {
mintingFinished = true;
MintingFinished();
return true;
} | 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 |
function allowance(address owner, address spender) public constant returns (uint256);
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 va... | 0 |
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) onlyPayloadSize(4 * 32) public returns (bool success) {
if(isContract(_to)) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receive... | 0 |
function getBalance() view public onlyOwner returns (uint256)
{
return address(this).balance;
} | 0 |
function setPauseMaster(address _pauseMaster) onlyOwner external returns (bool success) {
require(_pauseMaster != address(0));
pauseMaster = _pauseMaster;
return true;
} | 0 |
function sub(uint256 a, uint256 b) internal pure
returns (uint256)
{
assert(b <= a);
return a - b;
} | 0 |
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(... | 0 |
function USD(uint _id) constant returns (uint256);
}
contract TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function ChineseCookies() {
bakeCookie("A friend asks only for your time not your money.");
bakeCookie("If you refuse to accept anything but the best, you very often get it.");
bakeCookie("A smile is your passport into the hearts of others.");
bakeCookie("A good way to keep healthy is to eat more Chinese food.");
... | 0 |
function approve(address _spender, uint256 _amount)public returns (bool success) {
require(!lockstatus);
require( _spender != 0x0);
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= _balances[msg.sender]);
_balances[msg.sender] = _balances[msg.sender].sub(_value);
_balances[_to] = _balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function PreIco(uint256 _initialSupply, uint256 initialValue, address initialUpdater, uint256 end) {
initialSupply = _initialSupply;
remainingSupply = initialSupply;
tokenValue = initialValue;
updater = initialUpdater;
startBlock = block.number;
endTime = end;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockAdvisors3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x309F... | 0 |
function transfer(address _to, uint _value) canTransfer(msg.sender) public returns (bool) {
return super.transfer(_to, _value);
} | 0 |
function distributePresaleTokens(address _buyer, uint tokens) external onlyOwner whenNotPaused {
require(_buyer != address(0));
require(tokens > 0 && tokens <= limitPresale);
require(tokensDistributedPresale < limitPresale);
require(tokensDistributedPresale.add(tokens) < limitPresale);
tokensDistributedPresale = t... | 0 |
function voteYes(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(time() <= proposal.startTime.add(OPEN_VOTE_PERIOD), "Governance::voteYes: Proposal is no longer accepting yes votes");
uint proposalEndTime = proposal.startTime.add(TOTAL_VOTE_PERIOD);
if (proposalEndTime > withdra... | 0 |
function start_ICO2(uint256 price_tokn_ico2) public onlyOwner atStage(Stages.ICO1)
{
require(price_tokn_ico2 !=0);
require(now > ico1_enddate || balances[address(this)] == 0);
stage = Stages.ICO2;
stopped = false;
_price_tokn_ICO2 = price_tokn_ico2;
maxCap_ICO2 = 264000000 * 10 **18;
balances[address(this)] = (... | 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 SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint25... | 0 |
function random(uint64 upper) private returns (uint64 randomNumber) {
_seed = uint64(keccak256(keccak256(block.blockhash(block.number), _seed), now));
return _seed % upper;
} | 1 |
function Crowdsale() public {
owner = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
startTime = now;
endTime = 1521187200;
rate = 5000000000000000;
wallet = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
token = DragonToken(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
tokenReserve = 0xF615Ac471E066b5ae4BD211CC5044c7a... | 0 |
modifier isActivated() {
require(activated_ == true, "it's not ready yet");
_;
} | 0 |
modifier beforeEndTime() {
require(now < endTime);
_;
} | 0 |
function addFreezer(address freezer) auth public {
FreezerAuthority(authority).addFreezer(freezer);
} | 0 |
function update(uint256 newTotalSupply, uint256 reservedTokensNextDay) external onlyUpdater {
totalSupply = newTotalSupply;
uint256 daysSupply = newTotalSupply.sub(tokenContract.totalSupply());
statsByDay.push(Day(daysSupply, 0, reservedTokensNextDay, 0));
Update(newTotalSupply, reservedTokensNextDay);
} | 0 |
function finalize() public {
require(!isFinalized);
finalization();
emit Finalized();
isFinalized = true;
} | 0 |
modifier isNotTimeLockedFrom( address _from, address _to) {
require( whitelistedTransferer[_to] || ( now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]));
_;
} | 0 |
function assignTokens(address beneficiary, uint256 amount) private returns(uint256 lockedFor){
lockedFor = now + 45 days;
balances[beneficiary] = balances[beneficiary].add(amount);
releaseTime[beneficiary] = lockedFor;
} | 0 |
function isWhitelisted(address _wallet) public view returns (bool) {
return whitelist[_wallet].whitelisted;
} | 0 |
function getKebabsSincelastKebab(address adr) public view returns(uint256)
{
uint256 secondsPassed=min(KEBABER_TO_MAKE_1KEBAB,SafeMath.sub(now,lastKebab[adr]));
return SafeMath.mul(secondsPassed,workingKebaber[adr]);
} | 0 |
function claimVestedTokens(address _recipient) external {
uint256 yearsVested;
uint256 amountVested;
(yearsVested, amountVested) = calculateGrantClaim(_recipient);
require(amountVested > 0, "amountVested is 0");
Grant storage tokenGrant = tokenGrants[_recipient];
tokenGrant.yearsClaimed = yearsVested;
tokenGrant... | 0 |
function releaseBonus() public {
uint256 releaseTokens = 0;
if(block.timestamp > (startingTimestamp.add(phase1Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase1[msg.sender]);
lockupPhase1[msg.sender] = 0;
}
if(block.timestamp > (startingTimestamp.add(phase2Duration)))
{
releaseTokens = releaseTokens.... | 0 |
constructor() public {
term = 86400 - 600;
} | 0 |
function deauthorize(address _trustee_to_remove) returns (bool success) {
authorized[msg.sender][_trustee_to_remove] = false;
Deauthorization(msg.sender, _trustee_to_remove);
return true;
} | 0 |
function close() onlyOwner public
{
selfdestruct(msg.sender);
} | 0 |
function transfer(uint id, address newOwner, string newData)
validID(id) isOwnerOf(id) tradingIsEnabled returns(bool)
{
plots[id].owner = newOwner;
if (bytes(newData).length != 0) {
plots[id].metadata = newData;
}
Transfer(msg.sender, newOwner, id);
addPlot(newOwner, id);
removePlot(msg.sender, id);
return tr... | 0 |
function unlockAccount(address tokenOwner) public {
return data.unlockAccount(tokenOwner);
} | 0 |
function delWhiteList(address _address) onlyAdmin external {
require(whiteList[_address]);
whiteList[_address] = false;
emit DelWhiteList(_address);
} | 0 |
function transferFrom(address from, address to, uint256 value) external returns (bool) {
require(to != address(0));
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
_balances[from] = _balances[from].sub(value);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_ba... | 0 |
function issueTokenWithVesting_Team(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Team >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_Team) ) < time ) && ( vestingRelease_Team[_time] > 0 ) );
uint tokens = vestingRel... | 0 |
function blockTime() constant returns (uint32) {
return uint32(block.timestamp);
} | 1 |
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 retu... | 0 |
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).approve(msg.sender, _spender, _amount)) throw;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
} | 0 |
function withdrawEther(address traderAddr, address payable withdrawalAddr, uint amount) external
onlyActive()
onlyApprovedExchange(traderAddr) {
deductBalance(0, traderAddr, amount);
resetEmergencyRelease(traderAddr);
emit Withdrawal(0, traderAddr, withdrawalAddr, amount);
withdrawalAddr.transfer(amount);
} | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 |
function auctionExpired() public view returns (bool) {
return now > auctionEnd;
} | 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 updateTokensToInvestor(address _investorAddress, uint256 _tokenAmount) public returns(bool) {
require(investors[_investorAddress].isInvestor);
Investor storage currentInvestor = investors[_investorAddress];
currentInvestor.tokenAmount = currentInvestor.tokenAmount.add(_tokenAmount);
require(mycroToken.tran... | 0 |
function issue_Vesting_Team(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Team >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_Team) ) < time ) && ( vestingRelease_Team[_time] > 0 ) );
uint tokens = vestingRelease_Tea... | 0 |
function authCancel(address from) external returns (uint8 status) {
if (!masterKeys[from] || !trustedClients[msg.sender]) {
Unauthorized(from);
return 0;
}
bytes32 call = functionCalling[from];
if (call == bytes32(0)) {
NothingToCancel(from);
return 1;
} else {
AuthCancel(from, from);
functionCalling[from] =... | 0 |
function transferOwnership(address _newowner) external onlyOwner{
uint new_bal = balances[msg.sender];
owner = _newowner;
balances[owner]= new_bal;
balances[msg.sender] = 0;
} | 0 |
function getOwner() returns (address out) {
return owner;
} | 0 |
function authorized_triggerStashedPayoutTransfer(uint256 _cardId) external requireAuthorizedLogicContract {
Card storage card = allCards[_cardId];
address claimerAddress = card.claimer;
require(claimerAddress != address(0));
uint256 stashedPayout = cardIdToStashedPayout[_cardId];
require(stashedPayout > 0);
cardI... | 0 |
function buy()
public
payable
nonReentrant
returns (uint)
{
address investor = msg.sender;
uint256 payment = msg.value;
require(payment >= c_MinInvestment);
require(now < 1507766400);
uint stq = payment.mul(c_STQperETH);
m_token.mint(investor, stq);
m_funds.transfer(payment);
FundTransfer(investor, payment... | 0 |
function transferOwnership(address newOwner) public;
function _transferOwnership(address newOwner) internal onlyOwner {
require(newOwner != address(0), "Ownable: address is zero.");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.