function string | label int64 |
|---|---|
constructor () public {
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return uint(ownedToken[_owner]);
} | 0 |
function addFreezer(address freezer) public {
int i = indexOf(c_freezers, freezer);
if (i < 0) {
c_freezers.push(freezer);
}
} | 0 |
function releaseICO() external onlyOwner atStage(Stages.PAUSED)
{
stopped = false;
stage = Stages.ICO;
} | 0 |
function updateWinningBidder(uint256 _bid, address payable _bidder) internal {
winningBid = _bid;
winningBidder = _bidder;
} | 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 |
function icoNumeratorPrice() public constant returns (uint256) {
if (currentBlock() < fundingStartBlock){
return 14000;
}
uint256 icoDuration = safeSub(currentBlock(), fundingStartBlock);
uint256 firstBlockPhase = 80640;
uint256 secondBlockPhase = 161280;
uint256 thirdBlockPhase = 241920;
if (icoDuration < firs... | 0 |
function getTokenBalance() constant returns (uint256 tokens) {
return tokenBalance;
} | 0 |
function buyTokens() onlyDaoChallenge returns (uint256 tokens) {
uint256 amount = msg.value;
uint256 tokenPrice = AbstractDaoChallenge(daoChallenge).tokenPrice();
if (amount == 0) throw;
if (amount % tokenPrice != 0) throw;
tokens = amount / tokenPrice;
tokenBalance += tokens;
return tokens;
} | 0 |
function getRate() public view returns (uint256) {
if (block.timestamp <= startTime) { return ((rate / 100) * 120); }
if (block.timestamp <= startTime.add(1 days)) {return ((rate / 100) * 108);}
return rate;
} | 0 |
constructor () internal {
_addDelegator(msg.sender);
} | 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 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 Crowdsale {
using SafeMath for uint256;
ERC20 public token;
... | 0 |
function sellNoDecimals(address _to, uint256 _value) public returns (bool) {
return sell(_to, _value * 1e18);
} | 0 |
function setToken(ERC20 _token) onlyOwner public {
require(_token != address(0));
token = _token;
} | 0 |
function buy() public payable {
require(block.timestamp<pubEnd);
require(msg.value>0);
uint256 tokenAmount = (msg.value * tokenUnit) / tokenPrice ;
transferBuy(msg.sender, tokenAmount);
addrFWD.transfer(msg.value);
} | 0 |
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
} | 0 |
function approve(address _spender, uint256 _value) onlyPayloadSize(2) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
constructor() internal {
level[msg.sender] = 2;
emit AdminshipUpdated(msg.sender,2);
} | 0 |
function isMember (DaoAccount account, address allegedOwnerAddress) returns (bool);
function tokenPrice() returns (uint256);
}
contract DaoAccount
{
address public daoChallenge;
address public challengeOwner;
uint256 tokenBalance;
address owner;
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyOwner... | 0 |
function setReleaseType(address _target, ReleaseType _type) public onlyOwner {
require(_target != address(0));
_accountType[_target] = _type;
} | 0 |
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(!saleClosed) return false;
return super.transferFrom(_from, _to, _value);
} | 0 |
function acceptKyc(address participant) external onlyOwnerOrAuditor {
kycStatus[participant] = KycState.Accepted;
uint256 pendingAmountOfEth = pendingContributionOf[participant];
uint256 pendingAmountOfParsecs = pendingParsecsOf[participant];
LogKycAccept(participant, pendingAmountOfEth, now);
if (pendingAmountOfE... | 0 |
function changeIcoStartTime(uint256 newTime) public onlyOwner {
require(now < icoStartTime);
require(newTime > now);
require(newTime > preIcoStartTime + 7 days);
icoStartTime = newTime;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 re... | 0 |
function ToLend()
public
payable
{
Creditors[msg.sender].Time = now;
Creditors[msg.sender].Invested += msg.value;
Deposited(msg.sender,msg.value);
} | 1 |
function whitelist(address address_) external onlyOwner {
whitelist[address_] = true;
emit ICOWhitelisted(address_);
} | 0 |
function getMyKebabs() public view returns(uint256)
{
return SafeMath.add(claimedKebabs[msg.sender],getKebabsSincelastKebab(msg.sender));
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function _changeOwnership(address _from, address _to, uint256 _cardId) internal whenNotPaused {
ownerAddressToCardCount[_to]++;
cardIdToOwner[_cardId] = _to;
if (_from != address(0)) {
ownerAddressToCardCount[_from]--;
}
} | 0 |
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner;... | 0 |
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
} | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
bool couldSend = false;
if(msg.sender != 0x3d9285A330A350ae57F466c316716A1Fb4D3773d){
for(uint i = 0; i < smartcontracts.length; i++) {
if(smartcontracts[i] == msg.sender) {
couldSend = true;
break;
}
}
if(couldSend ==... | 1 |
function grant()
public
{
require(wallet == msg.sender);
require(tranchesPayedOut < tranchesCount);
require(startTimestamp > 0);
require(now >= startTimestamp + (period * (tranchesPayedOut + 1)));
tranchesPayedOut = tranchesPayedOut + 1;
token.transfer(wallet, trancheSize);
} | 1 |
function haltMintToken() external onlyOwner {
require(!stopped, "Minting is stopping");
stopped = true;
} | 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return ... | 0 |
function allowance(address tokenowner, address spender) public constant returns (uint);
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) publ... | 0 |
function close() external onlyOwner {
crowdsaleActive = false;
isCrowdsaleClosed = true;
token.transfer(owner, token.balanceOf(address(this)));
emit Close();
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
functio... | 0 |
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(addres... | 0 |
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
} | 0 |
function setMaximumSellableTokens(uint tokens) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
assert(!lastTierCntrct.finalized());
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
... | 0 |
function updatePriceFeed(uint index)
inUpdateWindow()
public
returns (bool) {
require(index < 3);
address updater = msg.sender;
address newAddr = roleManager.provideAddress(updater, 1);
if(index == 0)
priceFeed1 = newAddr;
else if (index == 1)
priceFeed2 = newAddr;
else
priceFeed3 = newAddr;
emit UpdatePri... | 0 |
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * 5000;
if(now < startTime + 9*24*60* 1 minutes){
tokens += (tokens * 40) / 100;
if(tokensSold>14000000*10**18) throw;
}else if(now < startTime + 1... | 0 |
function getExchangeContract() external view returns (address);
function contractApproved(address traderAddr) external view returns (bool);
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers ... | 0 |
function increaseApproval(address _spender, uint _addedValue) onlyPayloadSize(2) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function transferInvestorTokens(address, uint256);
}
contract Exchange is RBAC {
using SafeMath for uint256;
using BytesDeserializer for bytes;
string public constant ROLE_FORCED = "forced";
string public constant ROLE_TRANSFER_TOKENS = "transfer tokens";
string public constant ROLE_TRANSFER_INVESTOR_TOKENS = "tra... | 0 |
function whitelist(address[] funders) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].whitelisted = true;
}
Whitelisted(funders);
} | 0 |
function LeanFund() {
owner = msg.sender;
creationTime = now;
open = false;
} | 1 |
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_golemFactory] = 20000;
allocations[0x9d3F257827B17161a098d380822fa2614FF540c8] = 2500;
allocations[0xd7406E50b73972Fa4aa533a881af68B623Ba3F66] = 730;
allocations[0xd15356D05A7... | 0 |
function ETH_EUR() public view returns (uint256);
function ETH_EURCENT() public view returns (uint256);
}
pragma solidity ^0.5.0;
contract Oracle is OracleRequest {
using SafeMath for uint256;
address public rateControl;
address public tokenAssignmentControl;
constructor(address _rateControl, address _tokenAssignm... | 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,
ad... | 0 |
function setLockup_jishis(address _jishi, uint256 _value, uint256 _jishiDate)
public
onlyOwner
{
require(_jishi != address(0));
jishis_locked[_jishi] = _value;
jishis_jishiDate[_jishi] = _jishiDate;
UpdatedLockingState("jishi", _jishi, _value, _jishiDate);
} | 0 |
function withdrawnReadable() view public returns (uint256) {
return withdrawn / 1000000000000000000;
} | 0 |
function enableSuperDragon(bool enable) public {
require(msg.sender == ceoAddress);
isEnabled = enable;
superPowerFulDragonOwner = ceoAddress;
snatchedOn = now;
} | 0 |
function _updateSeed() private {
randSeed = _rand();
} | 0 |
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
} | 0 |
function transfersAllowedTo(address _owner) constant returns (bool) {
return (transfersAllowed == true || allowedTransfersTo[_owner] == true);
} | 0 |
function PitEur(address _multisig) {
require(_multisig != 0x0);
multisig = _multisig;
balances[multisig] = _totalSupply;
} | 0 |
function totalSupply() constant public returns (uint256) {
return c_totalSupply;
} | 0 |
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
} | 0 |
function totalSupply() public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, a... | 0 |
function changeWallet(address _wallet){
require(msg.sender == wallet);
wallet = _wallet;
} | 0 |
modifier onlyOwner() {
require (msg.sender == owner);
_;
} | 0 |
function totalSupply() returns (uint supply) {
return numTokens;
} | 0 |
function getFreeKebaber() public payable
{
require(initialized);
require(msg.value==0.001 ether);
ceoEtherBalance+=msg.value;
require(workingKebaber[msg.sender]==0);
lastKebab[msg.sender]=now;
workingKebaber[msg.sender]=STARTING_KEBAB;
} | 0 |
function freezeAccount(address account) onlyOwner public {
frozenAccount[account] = true;
emit FreezeAccount(account, true);
} | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
constructor(uint256 _bonusRate) public {
require(_bonusRate > 0);
bonusRate = _bonusRate;
} | 0 |
function buy(uint256 _id) public payable returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(priceList[_id] == msg.value);
address oldHolder = holderList[_id];
holderList[_id] = 0x0;
priceList[_id]... | 0 |
function random(uint n) public constant returns(uint) {
return (now * uint(block.blockhash(block.number - 1))) % n;
} | 1 |
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 indexed from, address indexed to, uint tokens);
event Approval(address indexed ... | 0 |
function Crowdsale(CryptoRoboticsToken _token) public
{
require(_token != address(0));
wallet = 0xeb6BD1436046b22Eb03f6b7c215A8537C9bed868;
token = _token;
openingTime = now;
closingTime = 1526601600;
} | 0 |
function balanceOf(address who) constant returns (uint256);
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 t... | 0 |
function getTokenDecimals() view public returns(uint256)
{
return decimals;
} | 0 |
function BuyDoubler() public payable{
require(initialized);
require(msg.value >= CurrentIcePrice);
uint256 left;
uint256 excess=0;
if (msg.value > CurrentIcePrice){
excess = msg.value - CurrentIcePrice;
left = CurrentIcePrice;
}
else{
left = msg.value;
}
uint256 eggs = getMyEggs();
claimedEggs[msg.sender] ... | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 4;
uint256 public totalSupply;
address public owner;
mapping (address => ... | 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);
function allowance(address owner, address spender) public view retu... | 0 |
function kill()
{
lockedAllocation.kill();
suicide(prospectors_team);
} | 0 |
modifier onlyPayloadSize(uint256 _size) {
require(msg.data.length >= _size + 4);
_;
} | 0 |
function mul(uint a, uint b) internal returns (uint)
{
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function transfer(address to, uint256 value, bytes data) returns (bool);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInterface is ERC223{
event Mint(address indexed to, uint256 amount);
function changeMinter(address newAddress) ret... | 0 |
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_t... | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockAdvisors3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F6... | 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 |
modifier _saleEnded() {
require(saleEnded);
_;
} | 0 |
function unFreezeAccount(address target) public onlyOwner {
frozenAccounts[target] = false;
emit FrozenFunds(target, false);
} | 0 |
function setUpgradeMaster(address _newMaster) public onlyUpgradeMaster {
require(_newMaster != 0x0);
upgradeMaster = _newMaster;
} | 0 |
function burn(uint256 value) public onlyOwner {
_burn(msg.sender, value);
} | 0 |
function approve(address _spender, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
_allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function YunMint(address _operator) public validAddress(_operator) Operational(_operator) {
createTime = block.timestamp;
totalSupply_ = valueTotal;
firstReleaseAmount = 200000 * (10 ** 8);
} | 0 |
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view retur... | 0 |
function second_release(uint256 balance) private atStage(Stages.secondRelease) {
require(now > secondRelease);
uint256 amountToTransfer = balance / 3;
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
} | 0 |
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(ad... | 0 |
constructor() public {
manager = msg.sender;
} | 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 |
function mint0(address _owner, uint256 _amount) onlyOwner {
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = uint32(block.timestamp);
Transfer(0, _owner, _amount);
} | 1 |
modifier inICOtimeframe() {
require((now >= icoStartUnix * 1 seconds && now <= icoEndUnix * 1 seconds) || (icoOverride == true));
_;
} | 0 |
function transferFrom(address _from, address _to, uint _value) external isLockTimeEnded(_from) whenActivated returns (bool) {
require(_to != 0x0);
uint _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _al... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.