function string | label int64 |
|---|---|
function TokenVesting(address _beneficiary, uint256 _startTime, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_startTime >= now);
require(_duration > 0);
require(_cliff <= _duration);
beneficiary = _beneficiary;
startTime = _startTime;
cliff = _startTim... | 0 |
function lockTeamTokens() public onlyOwner afterStageOneClosed {
require(teamTokensLockAddress == address(0) && totalSupply < HARD_CAP);
uint256 teamTokens = 1350000000 * 10**uint256(decimals);
TokenTimelock teamTokensLock = new TokenTimelock(this, mobilinkTeamAddress, uint64(block.timestamp) + 60 * 60 * 24 * 90);
... | 0 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(block.blockhash(block.number)) + block.timestamp + block.difficulty + block.number;
if (mulmod(random, 1, 2) == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function invest(address to) onlyActive public payable {
uint amount = msg.value;
uint tokenAmount = getCurrentBonus().mul(amount).mul(10 ** decimals / 100).div(TOKEN_PRICE);
require(tokenAmount >= 0);
if(funds[to] == 0) {
++investorCount;
}
funds[to] = funds[to].add(amount);
totalFunds = totalFunds.add(amount);... | 0 |
function Token(address amcWallet, address _upgradeMaster)
public
UpgradeableToken(_upgradeMaster)
{
totalSupply_ = INITIAL_SUPPLY;
balances[amcWallet] = INITIAL_SUPPLY;
Transfer(0x0, amcWallet, INITIAL_SUPPLY);
} | 0 |
modifier canTransfer() {
if(hold[msg.sender] > 0){
require(now > hold[msg.sender]);
}
_;
} | 0 |
function removeSupportedToken(address _address) public onlyOwner returns (bool) {
require(_address != 0x0);
uint256 length = supportedERC20Token.length;
for (uint256 i = 0; i < length; i++) {
if (supportedERC20Token[i] == _address) {
if (i != length - 1) {
supportedERC20Token[i] = supportedERC20Token[length - 1];... | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public TransferActive;
bool public ShareActive;
bool public CoinSaleActive;
string public name;
string public symbol;
uint256 public BuyPrice;
uint8 public decima... | 0 |
function gt(uint a, uint b) internal pure returns(bytes1) {
bytes1 c;
c = 0x00;
if (a > b) {
c = 0x01;
}
return c;
} | 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 getNowTimestamp() internal view returns (uint) {
return now;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
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 |
modifier canTransfer() {
if(msg.sender != founder) {
require(mintingFinished);
require(now > allowTransferTimestamp);
}
_;
} | 1 |
function setTransferFeeReceiver(address _address) public onlyOwner returns (bool) {
transferFeeReceiver = _address;
return true;
} | 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 receivePayment()isIssetRecepient timeCheck private {
uint depositMultiplier = getDepositMultiplier();
time[msg.sender] = now;
msg.sender.transfer(depositMultiplier);
allPercents+=depositMultiplier;
lastPayment =now;
emit PayOffDividends(msg.sender, depositMultiplier);
} | 0 |
modifier onlyPayloadSize(uint size) {
require(msg.data.length == size + 4);
_;
} | 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
if (now < presaleDeadline) {
require(assetProxy.transferFromWithReference(msg.sender, address(this), _value, _reference));
require(vesting.createVesting(_to, assetProxy, _value, 1, paymentInterval, schedule));
return true;
... | 0 |
function transferCustomToken(address _token, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyOwner public returns (bool) {
Token tkn = Token(_token);
return tkn.transfer(_to, _value);
} | 0 |
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
} | 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 sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uin... | 0 |
function extendTime(uint256 _timeExtension) onlyOwner public {
require(!finished);
require(now < endTime + timeExtension);
require(_timeExtension > 0);
timeExtension = timeExtension.add(_timeExtension);
require(timeExtension <= 7 days);
Extended(endTime.add(timeExtension));
} | 0 |
function burn(uint256 _value) public onlyOwner {
require(!burnt);
require(_value > 0);
require(_value <= balances[msg.sender]);
require(block.timestamp < 1690848000);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
burnt = true;
emit Burn(msg.sender, _value);
e... | 0 |
modifier isSuspended() {
require(state == State.Suspended);
_;
} | 0 |
function mint(address _to, uint256 _amount) external onlyRole(ROLE_MINT) returns (bool) {
require(_to != address(0));
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
MintLog(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
} | 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);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uin... | 0 |
function tokenFallback(address _from, uint256 _value, bytes _extraData) public returns (bool);
}
contract LuckyStrikeTokens {
using SafeMath for uint256;
string public name = "LuckyStrikeTokens";
string public symbol = "LST";
uint8 public decimals = 0;
uint256 public totalSupply;
mapping(address => uint256) publi... | 0 |
function cancelOrderInternal(LibOrder.Order memory order)
internal;
function updateFilledState(
LibOrder.Order memory order,
address takerAddress,
bytes32 orderHash,
uint256 orderTakerAssetFilledAmount,
LibFillResults.FillResults memory fillResults
)
internal;
function updateCancelledState(
LibOrder.Order me... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns... | 0 |
function Exchange(uint256 _delay) {
delay = _delay;
feeAccount = msg.sender;
addRole(msg.sender, ROLE_FORCED);
addRole(msg.sender, ROLE_TRANSFER_TOKENS);
addRole(msg.sender, ROLE_TRANSFER_INVESTOR_TOKENS);
addRole(msg.sender, ROLE_CLAIM);
addRole(msg.sender, ROLE_WITHDRAW);
addRole(msg.sender, ROLE_TRADE);
add... | 0 |
function getState() public returns(State) {
if (forcedRefund)
return State.Refunding;
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
} | 0 |
function addTip(address _from, bytes32 _to, uint _tip) public onlyOwners {
tips[_from][_to] += _tip;
balances[_to] += _tip;
lastTip[_from][_to] = now;
} | 1 |
function getNow() internal constant returns (uint256) {
return now;
} | 1 |
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
} | 0 |
function updateEndTime(uint256 newEnd) onlyOwner {
endTime = newEnd;
} | 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 signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedApprove(tokenOwner, spender, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) throw;
bought_tokens = true;
time_bought = now;
token.proxyPayment.value(this.balance - bounty)(address(this));
msg.sender.transfer(bounty);
} | 1 |
function era() public view returns (uint) {
return block.timestamp;
} | 1 |
function removeOversight(address addr) external multisig(sha3(msg.data)) {
oversightAddresses[addr] = false;
} | 0 |
function apSaleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
balances[_to] = balances[_to].add( tokens.mul(385)/1000 );
ap1[_to] = ap1[_to].add( tokens.mul(385)/1000 );
ap2[_to] = ap2[_to].add( tokens.mul(115)/1000 );
ap3[_to... | 0 |
function getTimestamp() internal constant returns(uint) {
return now;
} | 1 |
function safeSub(uint256 a, uint256 b)pure internal returns (uint256) {
assert(b <= a);
return a - b;
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
for(uint i = 1; i <= vestingReleaseRound_RND; i++)
{
vestingRelease_RND[i] = vestingRelease_RND[i].add(vestingAmountPerRound_RND);
}
for(uint i = 1; i <= vestingReleaseRound_Advisor;... | 0 |
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
} | 0 |
function fundPot(address player, uint256 amount)
private
{
require(minting);
pot = pot.add(amount);
mint(player, amount);
} | 0 |
function executeContract() public checkAuthorizedUser() {
require(address(this).balance > 0);
if (oracle.current() == EXPECTED) {
contractExecuted = true;
emit ContractExecuted("Payment sent to beneficiary.");
beneficiary.transfer(address(this).balance);
} else if (now >= expiration) {
contractExecuted = true;
... | 0 |
constructor(address _oracle, address _depositor, address _beneficiary) public payable Ownable() {
oracle = IOracle(_oracle);
depositor = _depositor;
beneficiary = _beneficiary;
contractExecuted = false;
expiration = now + TO_EXPIRE;
} | 0 |
function destroy() onlyOwner public {
selfdestruct(owner);
} | 0 |
function renounceOwnership() public onlyOwner {
OwnershipRenounced(owner);
owner = address(0);
} | 0 |
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) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address ind... | 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 betOnDozen(bool First, bool Second, bool Third)
{
betOnColumnOrDozen(First,Second,Third, BetTypes.dozen);
} | 0 |
function setReservedTokens(uint day, address[] funders, uint256[] reservedTokens) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].reservedTokensPerDay[day] = reservedTokens[i];
}
ReservedTokensSet(day, funders, reservedTokens);
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event... | 0 |
function buyTokens(address beneficiary) public whenNotPaused payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
if (weiAmount >= minWeiWhitelistInvestment) {
require(investorWhitelist[beneficiary]);
}
weiRaised = weiRaised.add(weiAmount);
investments[beneficia... | 0 |
function buyTokens(address investor) public payable {
require(investor != address(0));
require(now >= startTime && now <= endTime);
require(crowdsaleActive);
require(msg.value != 0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
require(tokensSold.add(tokens) <= goal);
weiRaised = weiRais... | 0 |
function SmartOToken() public {
balances[msg.sender] = initialSupply;
totalSupply = initialSupply;
} | 0 |
function isUnowned(uint id) constant validID(id) returns(bool) {
return plots[id].owner == 0x0;
} | 0 |
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING... | 0 |
modifier inProgress() {
require (!isFinished);
require (issuedTokensAmount < maxTokensAmount);
require (now <= endDate);
_;
} | 1 |
function Rouleth() private
{
developer = msg.sender;
blockDelay=2;
blockExpiration=200;
maxGamble=500 finney;
maxBetsPerBlock=5;
casinoStatisticalLimit=20;
} | 0 |
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public;
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId);
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince,... | 0 |
function balanceOf(address who) external view returns (uint256);
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 ERC20... | 0 |
function exchange(address receiver) public payable {
uint256 amount = msg.value;
uint256 price = getRate();
uint256 numTokens = amount.mul(price);
bool isPreICO = (now <= preICO.date);
bool isICO = (now >= icoStarts.date && now <= icoEnds.date);
require(isPreICO || isICO);
require(numTokens > 500);
if (isPreICO... | 0 |
function balanceOf(address who) external view returns (uint256);
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 Haruk... | 0 |
function transfer(address to, uint256 amount)
public
returns (bool success);
}
contract Reclaimable is AccessControlled, AccessRoles {
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RE... | 0 |
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (resul... | 0 |
function contributeFor(address _beneficiary) public payable returns (uint) {
target.contributeFor.value(msg.value)(_beneficiary);
} | 0 |
function closeSale() public onlyOwner {
require(!closed);
closed = true;
disableMinting();
} | 1 |
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 balanceOf(address _owner) constant returns (uint balance)
{
return balances[_owner];
} | 0 |
function canRefund() public view returns (bool) {
return totalWeiReceived < minCapWei && endTime < now && now <= refundDeadlineTime;
} | 0 |
modifier onUnlocked() {
require(now >= lock, "Wallet locked");
_;
} | 0 |
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function setUpdater(address _updater) external onlyOwner {
updater = _updater;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMathLibExt {
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function totalSupply() external constant returns (uint);
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);
fu... | 0 |
modifier whenNotPaused() {
require(now >= endDate);
_;
} | 1 |
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value)
public returns (bool);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event App... | 0 |
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING() constant returns (uint) {
return _END_MINTING;
} | 0 |
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
RoleAdded(addr, roleName);
} | 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 valu... | 0 |
function allowance(address owner, address spender) constant returns (uint256) {
return allowed[owner][spender];
} | 0 |
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
... | 0 |
function updatePromoter3(address _address) external onlyOwner {
require(_address != address(0x0));
promoter3 = _address;
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function setBounty(address _bounty, uint256 bountyTokens) onlyOwner external returns (bool success) {
require(_bounty != address(0));
bounty = _bounty;
uint256 bounties = bountyTokens * 10**18;
balances[bounty] = balances[bounty].add(bounties);
totalSupply = totalSupply.add(bounties);
NewTokens(bounties);
return... | 0 |
function getProposal(uint proposalId) external view returns (Proposal memory) {
return proposals[proposalId];
} | 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 LCD_newTest is ERC20 {
string public constant sy... | 1 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_... | 0 |
function Token() public {
creationTime = now;
} | 1 |
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
} | 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);
}
contract FoundersContract {
using SafeMath for uint256;
ROBOToken public toke... | 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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(addre... | 0 |
function mintAuditApproval(address _address, uint256 _value) public onlyAudit {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].audit = msg.sender;
if ((mintApprove[_address].adm... | 0 |
function removePlot(address addr, uint id) private {
uint n = plotsOwned[addr].length;
for (uint8 i = 0; i < n; i++) {
if (plotsOwned[addr][i] == id) {
plotsOwned[addr][i] = plotsOwned[addr][n - 1];
delete plotsOwned[addr][n - 1];
plotsOwned[addr].length--;
break;
}
}
} | 0 |
function burn(uint256 _value) public {
_burn(msg.sender, _value);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.