function string | label int64 |
|---|---|
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signed... | 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 inProgress() public view returns (bool) {
return now >= startDate && now <= endDate;
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
} | 0 |
function owned() {
owner = msg.sender;
} | 0 |
function addDelegator(address delegator) public onlyOwner{
super._addDelegator(delegator);
} | 0 |
function createEntry(string _alias, string _message) payable public {
require(msg.value > minimum_donation);
entries[running_id] = Entry(msg.sender, _alias, block.timestamp, msg.value, _message);
running_id++;
donationWallet.transfer(msg.value);
} | 1 |
function disableAdminForever() internal {
currAdminEpoch++;
adminsDisabledForever = true;
emit AdminDisabledForever();
} | 0 |
function settleContract(uint finalSettlementPrice) internal {
settlementTimeStamp = now;
settlementPrice = finalSettlementPrice;
emit ContractSettled(finalSettlementPrice);
} | 0 |
function getStats() constant returns (uint32, uint32, uint32, bool) {
return (
uint32(totalContribution / 1 finney),
uint32(totalSupply / 1 finney),
uint32(totalBonusTokensIssued / 1 finney),
purchasingAllowed
);
} | 1 |
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO4D already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
} | 0 |
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tok... | 0 |
function undo() public {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
} | 1 |
function owned() public {
owner = msg.sender;
} | 0 |
function _tokenAuction(uint256 tokenIndex, address seller, uint256 sellPrice) internal {
tokenAuction[tokenIndex] = TokenAuction(true, tokenIndex, seller, sellPrice, now);
TokenAuctionCreated(tokenIndex, seller, sellPrice);
kimsOnAuction++;
} | 1 |
function currentTime() public view returns (uint);
}
contract KnowsTime is IKnowsTime {
function currentTime() public view returns (uint) {
return now;
} | 0 |
function burn(uint256 _amount) external onlyDestroyer {
require(balances[destroyer] >= _amount && _amount > 0);
balances[destroyer] = balances[destroyer].sub(_amount);
totalSupply = totalSupply.sub(_amount);
Burn(_amount);
} | 0 |
function activateCurrency(address addr) internal {
if (!currencyActive[addr]) {
currencyActive[addr] = true;
approvedIndex.push(addr);
}
} | 0 |
function getResult(uint256 guessType, uint256 period)
public view returns (uint256){
require(guessType > 0);
require(period > 0);
require(results[guessType][period] > 0);
return results[guessType][period];
} | 0 |
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
} | 0 |
function setWallet(address _wallet) onlyOwner public returns(bool) {
wallet = _wallet;
WalletChange(_wallet , now);
return true;
} | 0 |
function publish(address genesis, bytes32 key, bytes32 data) public {
require((manager[genesis] == 0x0 && genesis == msg.sender) || manager[genesis] == msg.sender);
registry.setClaim(genesis, key, data);
} | 0 |
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.d... | 0 |
function time() constant returns (uint) {
return now;
} | 1 |
function checkProfitLossSinceInvestorChange() constant returns(uint profit_since_update_balances, uint loss_since_update_balances)
{
profit_since_update_balances=profitSinceChange;
loss_since_update_balances=lossSinceChange;
return;
} | 0 |
function redeem(string message) {
require (balances[msg.sender] >= 1);
require (now <= expirationDate);
balances[msg.sender] -= 1;
redeemed[msg.sender] += 1;
tokenRedemption(msg.sender, message);
} | 1 |
function activate() external onlyOwner returns (bool) {
isActivated = true;
return true;
} | 0 |
function getProfitFromSender() public view returns(uint256){
return getProfit(msg.sender);
} | 0 |
function distinctInvestors() public constant returns(uint){
return investorCount;
} | 0 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to) || isNewParent[_to]) {
if ((msg.sender==returnChildAddressForParent(_to)) || (returnChildForParentNew[_to]==msg.sender)) {
... | 1 |
function whitelist(address _address) external onlyOwner {
whitelisted[_address] = true;
} | 0 |
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
} | 0 |
function tridentDetails ()
external view returns
(
uint stakeMinimumTimestamp,
uint stakeMaximumTimestamp,
uint256 percentageLower,
uint256 percentageMiddle,
uint256 percentageUpper,
uint256 treasuryPercentage,
uint256 stakeMinimum,
uint256 stakeMaximum,
uint256 maxTotalSupply) {
stakeMinimumTimestamp = _st... | 0 |
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FallbackFailer {
function () {
throw;
} | 0 |
function party() {
if (block.timestamp < partyTime) throw;
uint value = holders[msg.sender];
if (value == 0) throw;
holders[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
} | 1 |
function init(address luckyStrikeContractAddress) public {
require(msg.sender == admin);
require(tokenSaleStarted == 0);
hardCap = 4500 ether;
salePeriod = 200 days;
team = 0x0bBAb60c495413c870F8cABF09436BeE9fe3542F;
balanceOf[0x7E6CdeE9104f0d93fdACd550304bF36542A95bfD] = 33040000;
balanceOf[0x21F73Fc4557a396233... | 0 |
function getPendingBurnRequest(bytes32 requestHash) internal view returns (uint nonce, Request memory request) {
require(requestHash != 0, "request hash is 0");
nonce = burnRequestNonce[requestHash];
request = burnRequests[nonce];
validatePendingRequest(request, requestHash);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
function approve(address _spender, uint256 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, u... | 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 |
function privateSaleUnlock(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < privateSaleLockTime);
uint nowTime = now;
require( nowTime > privateLockTimer[_time] );
uint tokens = privateLockWallet[_to][_time];
require(tokens > 0);
balances[_to] = balances[_to].add(tokens);... | 0 |
constructor() public {
owner = beneficiary;
totalSupply = INIT_TOTALSUPPLY * 10 ** uint256(decimals);
vestedAmount = 1000000000 * 10 ** uint256(decimals);
uint256 ownerBalances = totalSupply.sub(vestedAmount);
balances[owner] = ownerBalances;
releasedTime = now.add(2*365 days);
emit Transfer(address(0), owner, o... | 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 value... | 0 |
function married() constant returns (bool) {
return coupleConfirmations[a] && coupleConfirmations[b] && till >= now;
} | 1 |
function isUnlocked(address _owner) public constant returns (bool unlocked)
{
return lockedTillTime[_owner] < now;
} | 1 |
function addMinter(address minter) public onlyOwner{
super._addMinter(minter);
} | 0 |
function authorized_createCard(uint256 _socialNetworkType, uint256 _socialId, address _owner, address _claimer) external requireAuthorizedLogicContract returns (uint256) {
return _createCard(_socialNetworkType, _socialId, _owner, _claimer);
} | 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 updateMaxBet() private
{
if (payroll/(casinoStatisticalLimit*35) > maxGamble)
{
currentMaxGamble=maxGamble;
}
else
{
currentMaxGamble = payroll/(casinoStatisticalLimit*35);
}
} | 0 |
function transferFrom(address from, address to, uint value)
returns (bool success)
{
uint _allowance = allowed[from][msg.sender];
balances[to] = balances[to].safeAdd(value);
balances[from] = balances[from].safeSub(value);
allowed[from][msg.sender] = _allowance.safeSub(value);
Transfer(from, to, value);
return t... | 0 |
function approve(address _spender, uint256 _value) public
returns (bool success)
{
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
function setCoinsaleactive(bool newdata) public {
if (msg.sender == Owner) {CoinSaleActive = newdata;}
} | 0 |
function transfer(address _to, uint _value) external isLockTimeEnded(msg.sender) whenActivated returns (bool) {
require(_to != 0x0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function feeRate() public view returns (uint16){
return _feeRate;
} | 0 |
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 BasicToken is ERC20Basic {
using SafeMath for u... | 0 |
function transferTokensLeftOver() internal {
require(!remainingTransfered);
require(maxTokensRaised > tokensRaised);
remainingTransfered = true;
uint256 remainingTokens = maxTokensRaised.sub(tokensRaised);
token.distributeCrowdsaleTokens(msg.sender, remainingTokens);
} | 0 |
function activateSaleContract(address saleContractAddress) public onlyOwner {
require(saleContractAddress != address(0));
require(!saleContractActivated);
saleContract = saleContractAddress;
saleContractActivated = true;
_mint(saleContract, _tokensForSale);
_tokensForSale = 0;
emit SaleContractActivation(saleCon... | 0 |
function setAccountAllowance(address from, address to, uint256 amount) onlyOwnerUnlocked {
allowance[from][to] = amount;
activateAllowanceRecord(from, to);
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
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... | 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
functio... | 0 |
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 SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, strin... | 0 |
function transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) {
require( _to != 0x0);
require (balances[_from] >= _amount && _amount > 0);
balances[_from] = (balances[_from]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
Transfer(_from, _to, _amount)... | 0 |
function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x + _y;
require(z >= _x);
return z;
} | 0 |
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 constant returns (uint256 remaining);
event Transfer(address indexed _from, ad... | 0 |
function getLastTimeUpdated()
public
view
returns(uint256)
{
return lastTimeUpdated;
} | 0 |
function Zmbc() TokenERC20() public {}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
... | 0 |
function setMarketMaker(address _address) public onlyOwner returns (address) {
marketMakerAddress = _address;
return marketMakerAddress;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSe... | 0 |
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
... | 0 |
function listAddress( address _user, uint _cap ) public onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 1 |
function mul(uint256 a, uint256 b) internal pure
returns (uint256)
{
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
constructor(ERC20 _token) public {
require(address(_token) != address(0));
v12MultiSig = msg.sender;
token = _token;
} | 0 |
function zReceiveFunds() payable public {
} | 1 |
function _updateNextWithdrawalTime(uint256 oldWithdrawal) internal view returns (uint256)
{
uint currentTimestamp = block.timestamp;
require(oldWithdrawal <= currentTimestamp, "You need to wait the next withdrawal period");
if (oldWithdrawal == 0)
{
return _timeShiftPeriod.add(currentTimestamp);
}
return oldWit... | 0 |
function getLostAndFoundMaster() internal view returns (address);
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(msg.sender == getLostAndFoundMaster());
token_contract.approve(agent, tokens);
} | 0 |
function unreserve(uint32 index) managerOnly {
require(index < unknownInvestors.length && unknownInvestors[index].reserved);
assert(unknownReserved > 0);
unknownReserved--;
unreserveTokens(unknownInvestors[index].tokens);
unknownInvestors[index].reserved = false;
ReserveUnknown(false, index, 0, 0);
} | 0 |
function addDocHash(bytes32 hash) public ownerOnly {
Record memory newRecord = Record(block.timestamp, block.number);
docHashes[hash] = newRecord;
} | 0 |
function ReleaseDate() public constant returns (uint) { return Date; }
function WithdrawEnabled() public constant returns (bool) { return Date > 0 && Date <= now; }
function() public payable { deposit(); }
function deposit() public payable {
if (msg.value > 0) {
if (msg.value >= MinimumDeposit())
Deposits[msg.sen... | 1 |
function signedApproveCheck(Data storage self, address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.NotTransferable;
bytes32 hash = signedApprov... | 0 |
function buyIPC() payable isPurchasable whenNotPaused public returns (uint256) {
require(msg.value >= minimumEtherAmount);
uint256 tokenAmount = safeMul(msg.value, exchangeRate);
tokenAmount = safeDiv(tokenAmount, 1 ether);
require(allowance[vendorWallet][this] >= tokenAmount);
balanceOf[msg.sender] = safeAdd(bala... | 0 |
function editWhitelist(address _address, bool isWhitelisted) external onlyOwner returns (bool) {
whitelistedBeforeActivation[_address] = isWhitelisted;
return true;
} | 0 |
function setFeeAccount(address _feeAccount) external onlyRole(ROLE_SET_FEEACCOUNT) {
feeAccount = _feeAccount;
FeeAccountChanged(feeAccount);
} | 0 |
function changeDeveloper(address new_dev)
noEthSent
onlyDeveloper
{
developer=new_dev;
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
return c;
} | 0 |
function withdrawDifferentToken(address _token, bool _erc20old) public onlyOwner returns (bool) {
require(ERC20(_token).balanceOf(address(this)) > 0);
if (_erc20old) {
ERC20Old(_token).transfer(msg.sender, ERC20(_token).balanceOf(address(this)));
} else {
ERC20(_token).transfer(msg.sender, ERC20(_token).balanceOf(... | 0 |
function finalizeMigration(address sender, Proxy identity) onlyAuthorized onlyOlderOwner(identity, sender) {
require(migrationInitiated[identity] != 0 && migrationInitiated[identity] + adminTimeLock < now);
address newIdManager = migrationNewAddress[identity];
delete migrationInitiated[identity];
delete migrationNe... | 0 |
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 tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed bu... | 0 |
function freeze(uint256 _value, uint256 _unFrozenTime) nonReentrant public returns (bool) {
require(balances[msg.sender] >= _value);
require(_unFrozenTime > createTime);
require(_unFrozenTime > block.timestamp);
balances[msg.sender] = balances[msg.sender].sub(_value);
frozenBalances[frozenBalanceCount] = FrozenBal... | 0 |
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() p... | 0 |
function mint(uint256 mintedAmount) multisig(sha3(msg.data)) {
treasuryBalance += mintedAmount;
totalSupply += mintedAmount;
} | 0 |
function changeRate(uint256 _numerator, uint256 _denominator) public onlyOwner
returns (bool success)
{
if (_numerator == 0) _numerator = 1;
if (_denominator == 0) _denominator = 1;
buyPrice = (_numerator.mul(DEC)).div(_denominator);
return true;
} | 0 |
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
} | 0 |
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 ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function isSane(CrowdsaleToken token) public constant returns (bool);
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract GenericCrowdsale is Haltable {
using SafeMath for uint;
CrowdsaleToken public token;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundi... | 0 |
function BountyHunter() public {
for (uint i = 0; i < 8; i++) {
data[i].hunterPrice = 5000000000000000;
data[i].user = msg.sender;
data[i].last_transaction = block.timestamp;
}
} | 1 |
function amountForSale() public view returns (uint256) {
return _amountForSale;
} | 0 |
function recover(bytes32 hash, bytes sig) public pure returns (address) {
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;
}
if (v != 27 && v != 28) {
retu... | 0 |
function unfreeze(uint256 _value)public returns (bool success) {
if (freezeOf[msg.sender] < _value) revert();
if (_value <= 0) revert();
freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);
balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
emit Unfreeze(msg.sender, _value);... | 0 |
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
} | 0 |
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 tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed bu... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.