function string | label int64 |
|---|---|
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 who) external view returns (uint256);
function allowance(address owner,... | 0 |
function transfer(uint256 tokens, address recipient) noEther {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) throw;
DaoAccount recipientAcc = accountFor(recipient, false);
if (recipientAcc == DaoAccount(0x00)) throw;
account.transfer(tokens, recipientAcc);
notifyTransfer(msg... | 0 |
function recalcBonuses() internal {
tokensPerWei5 = tokensPerWeiPlusBonus(5);
tokensPerWei7 = tokensPerWeiPlusBonus(7);
tokensPerWei10 = tokensPerWeiPlusBonus(10);
} | 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;
uint256 totalSupply_;
function totalSupply() public view ret... | 0 |
function deposit(uint _value, uint _forTime) public returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
if (erc20old) {
ERC20Old(originalToken).transferFrom(msg.sender, address(this), _value);
} else {
require(ERC20(originalToken).transferFrom(msg.sender,... | 0 |
function transfer(address _to, uint _value)
public
onlyWhenTransferEnabled
validDestination(_to)
returns (bool) {
return super.transfer(_to, _value);
} | 0 |
function check_race_finished() view internal returns(bool){
if(race_number == 0){
return true;
}else{
return races[race_number].block_finish != 0;
}
} | 0 |
function allowance(address owner, address spender)public view returns (uint256);
function transferFrom(address from, address to, uint256 value)public returns (bool ok);
function approve(address spender, uint256 value)public returns (bool ok);
function transfer(address to, uint256 value)public returns (bool ok);
eve... | 0 |
function contributeFor(address _beneficiary) public payable returns (uint);
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _benefic... | 0 |
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
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.sen... | 0 |
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 v... | 0 |
modifier canMint() {
require(!mintingFinished);
_;
} | 0 |
function setUpgradeTarget(address target) external {
require(canUpgrade());
require(target != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeTarget = UpgradeTarget(target);
require(upgradeTarget.isUpgradeTarget());
require(upgradeTarget.originalSupply() =... | 0 |
function upgradeMeAdmin(address newAdmin) only_admin() external {
require(msg.sender != owner, "owner cannot upgrade self");
_setAdmin(msg.sender, false);
_setAdmin(newAdmin, true);
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
} | 0 |
function contributeFor(address _beneficiary) public payable returns (uint);
}
contract CrowdsaleProxy is ICrowdsaleProxy {
address public owner;
ICrowdsale public target;
function CrowdsaleProxy(address _owner, address _target) public {
target = ICrowdsale(_target);
owner = _owner;
} | 0 |
function doRandom(uint64 upper) public ifAdmin returns(uint64 randomNumber) {
_seed = uint64(keccak256(keccak256(block.blockhash(block.number), _seed), now ));
uint64 _randomNumber = _seed % upper;
LogRandom(_randomNumber);
return _randomNumber;
} | 1 |
function allowance(address tokenowner, address spender) public constant returns (uint) {
return allowed[tokenowner][spender];
} | 0 |
function hasRole(address _from, bytes32 _role, address _to) constant returns(bool) {
return _isFuture(rolesExpiration[_getRoleSignature(_from, _role, _to)]);
} | 0 |
function mint(address from, address receiver, uint256 value) internal {
require(receiver != 0x0, "Address can not be 0x0");
require(value > 0, "Value should larger than 0");
balances[receiver] = balances[receiver].add(value);
_totalsupply = _totalsupply.add(value);
mintedTokens = mintedTokens.add(value);
emit Min... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
if(msg.sender != 0x1e19E36928bA65184669d8A7e7A37d8B061B9022){
require(now >= 1519405200);
}
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] ... | 1 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function receiveCreateAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) public returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(_from, _token, _tokenId, _startPrice, _duration);
emit ReceiveCreateAu... | 0 |
function isSubjectApproved() public view returns (bool) {
return votesYes > votesNo;
} | 0 |
function reservedTokens(address funder, uint day) external view returns (uint256) {
return knownFunders[funder].reservedTokensPerDay[day];
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function balanceOf(address who) constant returns (uint);
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 valu... | 0 |
constructor() public {
owner = 0xaDdFB942659bDD72b389b50A8BEb3Dbb75C43780;
_balances[owner] = 89000000 * 10 ** decimals;
emit Transfer(address(0), owner, 89000000 * 10 ** decimals);
} | 0 |
function mintTimelocked(address _to, uint256 _amount, uint256 _releaseTime) public
onlyOwner canMint returns (TokenTimelock)
{
TokenTimelock timelock = new TokenTimelock(this, _to, _releaseTime);
mint(timelock, _amount);
return timelock;
} | 0 |
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
} | 0 |
function terminateTokenVesting() public onlyOwner
{
require(_alocatedWibxVestingTokens == 0, "All withdrawals have yet to take place");
if (totalWibxVestingSupply() > 0)
{
_wibxToken.transfer(_wibxToken.taxRecipientAddr(), totalWibxVestingSupply());
}
selfdestruct(address(uint160(owner())));
} | 0 |
function mintTokens(address recipient, uint amount)
returns (bool ok)
{
require(msg.sender == mintMaster);
require(amount > 0);
balances[recipient] = balances[recipient].safeAdd(amount);
totalSupply = totalSupply.safeAdd(amount);
LogMintTokens(recipient, amount, balances[recipient], totalSupply);
Transfer(addre... | 0 |
function getWinners()
public
view
finishedGame
returns(address[] memory players, uint[] memory prizes)
{
var(numWinners, numFixedAmountWinners) = getNumWinners();
uint totalNumWinners = numWinners + numFixedAmountWinners;
players = new address[](totalNumWinners);
prizes = new uint[](totalNumWinners);
uint ind... | 1 |
function withdrawFoundersTeamAndAdvisors() public onlyOwner {
require (FoundersTeamAndAdvisorsAccumulated > 0);
owner.transfer(FoundersTeamAndAdvisorsAccumulated);
FoundersTeamAndAdvisorsAccumulated = 0;
} | 0 |
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) pu... | 0 |
function disableBetting()
noEthSent
onlyDeveloper
{
state=States.inactive;
} | 0 |
function transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) {
require( _to != 0x0);
require(_from == address(this));
balances[_from] = (balances[_from]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
if (_from == 0x0)
{
_totalsupply = _totalsupply... | 0 |
function transfer(address _to, uint _value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.transfer(_to, _value);
} | 0 |
function updateTokenBalance() public;
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
byt... | 0 |
function calcRequestHash(Request request) internal pure returns (bytes32) {
return keccak256(abi.encode(
request.requester,
request.amount,
request.btcDepositAddress,
request.btcTxid,
request.nonce,
request.timestamp
));
} | 0 |
function transfer(address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function BetGame(address _pls)
{
initializeTime = now;
roundCount = 1;
pls = ERC20(_pls);
} | 1 |
function submitNewContract(string _name, address[] _signers, string _description, bytes32 _sha256sum) onlyAdmin
{
if (contractIndex[_sha256sum]!=0) throw;
if (_signers.length==0) throw;
contractIndex[_sha256sum]=contracts.length;
contracts.push(Contract(_name, _description, contractIndex[_sha256sum], _sha256sum, _... | 1 |
function buyLambo() {
require (block.timestamp > lamboTime && msg.sender == niece);
Lambo(this.balance);
msg.sender.transfer(this.balance);
} | 1 |
function refund() external {
checkGoalReached();
require ((amountRaisedInWei < fundingMinCapInWei)
&& (isCrowdSaleClosed)
&& (now > fundingEndTime)
&& (fundValue[msg.sender] > 0));
uint256 ethRefund = fundValue[msg.sender];
fundValue[msg.sender] = 0;
msg.sender.transfer(ethRefund);
Refund(msg.sender, ethRefund... | 0 |
function getTokenRate() view public returns(uint256)
{
return rate;
} | 0 |
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
} | 0 |
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
} | 0 |
function setEndDate(uint256 _endTime)
external onlyOwner whenNotPaused
{
require(now <= _endTime);
require(startTime < _endTime);
endTime = _endTime;
} | 0 |
function transfer(uint256 tokens, DaoAccount recipient) noEther onlyDaoChallenge {
if (tokens == 0 || tokenBalance == 0 || tokenBalance < tokens) throw;
if (tokenBalance - tokens > tokenBalance) throw;
tokenBalance -= tokens;
recipient.receiveTokens(tokens);
} | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(stageOneClosed) {
return super.transferFrom(_from, _to, _value);
}
return false;
} | 0 |
function deployIdeas(address ref) public{
require(initialized);
address _deployer = msg.sender;
if(referrals[_deployer] == 0 && referrals[_deployer] != _deployer){
referrals[_deployer]=ref;
}
uint256 myIdeas = getMyIdeas();
uint256 newIdeas = myIdeas.div(clones_to_create_one_idea);
arrayOfClones[_deployer] = ar... | 0 |
function enter_race(uint8 class, uint8 variant, bool repellent) public payable{
require(class < 3,"class");
uint fee = calculate_fee(class,repellent);
uint contribution = calculate_fee(class,false);
require( msg.value == fee, "payment");
require(variant < 3,"variant");
require(!check_race_started(),"started");
r... | 0 |
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSaleInClosedPreSale = 60000000 * 10 ** 18;
bonusInPr... | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint25... | 0 |
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 StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
ma... | 0 |
constructor() public {
owner = msg.sender;
_totalBalance[owner] = _totalSupply;
_accountType[owner] = ReleaseType.Private1;
} | 0 |
modifier isActive() {
require(state == State.Active);
_;
} | 0 |
function withdraw(address _address) private {
uint256 balance = getUserBalance(_address);
if (deposit[_address] > 0 && address(this).balance >= balance && balance > 0) {
withdrawals[_address] = withdrawals[_address].add(balance);
time[_address] = now;
if (withdrawals[_address] >= deposit[_address].mul(2)){
deposi... | 0 |
function updateMaxCapEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateMaxCapEth") {
maxCapWei = _newValue * 1e18;
} | 0 |
function signedApproveHash(Data storage , address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
hash = keccak256(signedApproveSig, address(this), tokenOwner, spender, tokens, fee, nonce);
} | 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 |
modifier onlyExpirableSwaps(bytes32 _swapID) {
require(now >= swaps[_swapID].timelock, "swap not expirable");
_;
} | 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 release() public {
address who = msg.sender;
uint256 teamTokens = _teamToRelease(who);
uint256 advisorsTokens = _advisorsToRelease(who);
uint256 tokens = teamTokens.add(advisorsTokens);
require(tokens > 0);
if (teamTokens > 0)
teamReleased[who] = teamReleased[who].add(teamTokens);
if (advisorsTokens > ... | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance);
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 return... | 0 |
function bringCat (uint catId) public {
require(now < releaseDate );
catOwners[catId] = msg.sender;
target.transferFrom(msg.sender, this, catId);
} | 0 |
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function unlock() public {
if (now < unlockedAt) throw;
uint vaultBalance = token.balanceOf(address(this));
if (!token.transfer(recipient, vaultBalance)) throw;
} | 1 |
function divides(uint a, uint b) public pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
} | 0 |
function isLocked(address addr) public view returns (bool) {
return _lock_list[addr];
} | 0 |
function massTransfer(address [] _holders) public onlyOwner {
uint256 count = _holders.length;
assert(paySize * count <= balanceOf(msg.sender));
for (uint256 i = 0; i < count; i++) {
transfer(_holders [i], paySize);
}
Wasted(owner, tokensSpent, now);
} | 1 |
function burn(uint256 _value) public onlyOwner {
_burn(msg.sender, _value);
} | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) public {
require(_newFounderMultiSigAddress != address(0));
require(msg.sender == founderMultiSigAddress);
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function add(uint _version, uint _field, uint _value, string _dataInfo) public onlyOwner {
contentCount++;
settings[_field] = _value;
emit Setting(_version, block.timestamp / (1 days), _field, _value, _dataInfo);
} | 0 |
function getSquareWins(uint home, uint away) public view returns (uint numSquareWins, uint totalWins);
function isFinalized() public view returns (bool);
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function upgradeFrom(address from, uint value) public;
}
contract UpgradeableToken is EIP20Token, Burnable {
using SafeMath for uint;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint public totalUpgraded = 0;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
e... | 0 |
function isActive(uint id) constant returns (bool active) {
return offers[id].active;
} | 0 |
function set_centralAccount(address central_Acccount) external onlyOwner {
central_account = central_Acccount;
} | 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 |
function transferToAddress(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
function advSptIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advSptVestingTime);
uint nowTime = now;
require( nowTime > advSptVestingTimer[_time] );
uint tokens = advSptVestingSupplyPerTime;
require(tokens <= advSptVestingBalances[_time]);
require(tokens > 0);
r... | 0 |
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(msg.sender == getLostAndFoundMaster());
token_contract.approve(agent, tokens);
} | 0 |
contract token { function transfer(address receiver, uint amount){ } }
contract Crowdsale {
using SafeMath for uint256;
address public wallet;
address public addressOfTokenUsedAsReward;
token tokenReward;
uint256 public startTime;
uint256 public endTime;
uint256 public weiRaised;
uint256 public tokensSold;
eve... | 0 |
function transferTokenOwnership(address _newTokenOwner) public onlyOwner {
require(_newTokenOwner != address(0));
require(owner == msg.sender);
Owned(token).transferOwnership(_newTokenOwner);
} | 0 |
function BPESOToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
function destroy() onlyOwner public {
selfdestruct(owner);
} | 0 |
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
} | 0 |
function decimals() public view returns (uint);
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... | 0 |
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 who) external view returns (uint256);
function allowance(address owner,... | 0 |
function canWithdraw(address _thePool)
external
view
returns (bool)
{
if (now >= performers[_thePool].endTime) {
return true;
}
} | 0 |
function isDelegator(address account) public view returns (bool) {
return _delegators.has(account);
} | 0 |
function motionVoting(uint motionID)
public
view
returns (bool)
{
return now < motionStartTime[motionID] + votingPeriod;
} | 0 |
function approveAndCall(address currency, address spender, uint256 amount, bytes extraData) multisig(sha3(msg.data)) spendControl(currency, amount) onlyWithOversight {
Token(currency).approveAndCall(spender, amount, extraData);
PerformedApprove(spender, amount);
} | 0 |
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) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _... | 0 |
constructor() public{
_supply = 319000000*(10**8);
_balances[freezeOwner] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1586995200, unfreezeValue:9570000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeT... | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(a... | 0 |
function updatePrenup(string _prenupAgreement) public{
require((msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address) && (partner1_voted_update_prenup == true)&&(partner2_voted_update_prenup == true));
prenupAgreement = _prenupAgreement;
saveContractEvent("Update - Prenup", "Prenup... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.