function string | label int64 |
|---|---|
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic
{
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender,... | 0 |
function hasBalance(address _beneficiary, uint _releaseDate) public view returns (bool);
function balanceOf(address _owner) public view returns (uint);
function ethBalanceOf(address _owner) public view returns (uint);
function refundableEthBalanceOf(address _owner) public view returns (uint);
function getRate(uint ... | 0 |
function allowance(address owner, address spender) public constant 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 o... | 0 |
function isEmptyString (string a) internal pure returns (bool) {
return (compareStrings(a, ""));
} | 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, ... | 0 |
function hatchEggs(address ref) public{
require(initialized);
if(referrals[msg.sender] == 0 && referrals[msg.sender] != msg.sender){
referrals[msg.sender] = ref;
}
uint256 eggsUsed = getMyEggs();
uint256 newCHICKEN = SafeMath.div(eggsUsed,EGGS_TO_HATCH_1CHICKEN);
hatcheryCHICKEN[msg.sender] = SafeMath.add(hatche... | 0 |
function fetchDividendsFromP3X()
public
{
lastDividendsFetched = now;
uint256 dividends = p3xContract.dividendsOf(address(this), true);
if(dividends > 0) {
p3xContract.withdraw();
totalDividendPoints = totalDividendPoints.add(dividends.mul(POINT_MULTIPLIER) / totalSupply);
totalOutstandingDividends = totalOutst... | 0 |
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
function burn(uint256 value) public;
}
contract ICOContract {
function setTokenCountFromPreIco(uint256 value) public;
}
contract Crowdsale is Ownable {
using SafeMat... | 0 |
function deposit(uint _value, uint _forTime) public payable returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
balances[msg.sender] = balances[msg.sender].add(msg.value);
depositLock[msg.sender] = now + _forTime * 1 hours;
return true;
} | 0 |
function addSignature(string digitalFingerprint, string signature)
isOwner {
fingerprintSignatureMapping[sha3(digitalFingerprint)] = signature;
SignatureAdded(digitalFingerprint, signature, now);
} | 1 |
function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public {
require(_gameOpponent != address(this));
require(_gameTime == 0 || (_gameTime > 1514764800));
gameOpponent = _gameOpponent;
gameTime = _gameTime;
status = 0;
emit BeginGame(address(this), _gameOpponent, _gameTime);
} | 0 |
function withdraw(uint amount) {
if( isOwner() && now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 )
msg.sender.send( amount );
}
} | 1 |
function withdrawCashReserveFund() public onlyOwner {
require(CashReserveFundAccumulated > 0);
owner.transfer(CashReserveFundAccumulated);
CashReserveFundAccumulated = 0;
} | 0 |
function setTotalAllowed(address _owner, uint256 _newValue) internal
{
totalAllowed[_owner]=_newValue;
} | 0 |
function updateRate() internal returns (bool) {
if (now >= startTime.add(weeklength.mul(4))) {
rate = 200;
}
else if (now >= startTime.add(weeklength.mul(3))) {
rate = standardrate;
}
else if (now >= startTime.add(weeklength.mul(2))) {
rate = standardrate.add(earlybonus.sub(40));
}
else if (now >= startTime.a... | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(validPurchase());
require(TOKENS_SOLD<maxTokensToSale);
uint256 weiAmount = msg.value.div(10**16);
uint256 tokens = calculateTokens(weiAmount);
weiRaised = weiRaised.add(msg.value);
... | 0 |
function doLockdown() external only_owner() no_lockdown() {
disableAdminForever();
adminLockdown = true;
emit AdminLockdown();
} | 0 |
modifier allowedPayments(address payer, uint value) {
if (isPreICOPrivateOpened || isPreICOPublicOpened || isICOOpened) {
revert();
}
if (!isPreICOPrivateClosed || !isPreICOPublicClosed || !isICOClosed) {
revert();
}
if (block.timestamp < ICO_START_TIME) {
revert();
}
_;
} | 1 |
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0), "newOwner must be not 0x0");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
} | 0 |
function rest() returns (bool success){
require(balanceOf[msg.sender] >= 5000);
balanceOf[this] += 5000;
balanceOf[msg.sender] -= 5000;
restFinish[msg.sender] = block.timestamp + 3 days;
return true;
} | 1 |
function taxRecipientAddr() public view returns (address)
{
return _taxRecipientAddr;
} | 0 |
function checkWithdrawValue(uint256 amountTokensInSubunit) public constant returns (uint256 weiValue) {
require(amountTokensInSubunit > 0);
require(balanceOf(msg.sender) >= amountTokensInSubunit);
uint256 withdrawValue = amountTokensInSubunit / currentPrice.numerator;
require(this.balance >= withdrawValue);
return... | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
} | 0 |
function buyBoosterPack() public payable {
uint amount = msg.value/cardCost;
uint blockNumber = block.timestamp;
for (uint i = 0; i < amount; i++) {
_createCard(i%5 == 1 ? (uint256(keccak256(i+nonce+blockNumber)) % 50) : (uint256(keccak256(i+nonce+blockNumber)) % 50) + (nonce%50), msg.sender);
}
nonce += amount;
... | 1 |
function takeOwnership(uint256 tokenID) public;
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 token... | 0 |
function finalize() external onlyOwner {
require (isFinalized == false);
require(msg.sender == owner);
require(_raised >= tokenCreationMin);
require(_raised > 0);
if (now < fundingEndTime) {
require(_raised >= tokenCreationCap);
}
else
require(now >= fundingEndTime);
transferTokenOwnership(owner);
isFinalize... | 0 |
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
require(addr != 0x0);
transferAgents[addr] = state;
} | 0 |
function mine() returns(bool success){
if(date_check() != true){
current_remaining = _maxMiningReward - _currentMined;
if((current_remaining > 0) && (_currentMined != 0)){
_currentMined += current_remaining;
balances[contract_owner] += current_remaining;
Transfer(this, contract_owner, current_remaining);
current... | 0 |
function myTokenShare()
external
view
returns(uint256)
{
return totalSupply > 0 ? shareholders[msg.sender].tokens.mul(100) / totalSupply : 0;
} | 0 |
function _transfer(address from, address to, uint256 amount) internal {
require(amount <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
if(saleEndTime > block.timestamp)
_amountForSale = _balances[address(this)];
} | 0 |
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
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 spen... | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowance[msg.sender][_spender] == 0));
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
} | 0 |
function FoundersContract(address _token) public {
token = ROBOToken(_token);
balances_freez_one[muhtov] = 6840000 * 1 ether;
balances_freez_one[scherbakov] = 6840000 * 1 ether;
balances_freez_one[sattarova] = 320000 * 1 ether;
balances_freez_one[roma_kiev] = 900000 * 1 ether;
balances_freez_one[iliya] = 540000 *... | 0 |
function storeProof(string sha256) {
proofs[sha256] = block.timestamp;
} | 1 |
modifier onlyUnlocked() {
uint nowtime = block.timestamp;
uint futuretime = 1550537591;
if(nowtime > futuretime) {
_;
} else {
require(!lockedAddress[msg.sender]);
_;
}
} | 0 |
modifier saleIsOn() {
require((now > startTime && now < endTime)||(now > startPreICO && now < endPreICO));
_;
} | 0 |
function call(address contract_address) public payable {
LuckyNumber(contract_address).takeAGuess.value(msg.value)(uint8(keccak256(now, address(0xd777c3F176D125962C598E8e1162E52c6C403606)))%10);
} | 1 |
function setTransmitProduct(string memory pname, uint index, string memory smessage) payable public {
bool checkProduct = checkProductExist(pname);
if(checkProduct){
address radress = rlist[pname][index].rqaddress;
string memory wid = appendString(WallettoString(radress),pname);
bool cwallet = checkBWalletexist(wi... | 0 |
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
} | 0 |
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0);
require(!(b == -1 && a == INT256_MIN));
int256 c = a / b;
return c;
} | 0 |
function getCurrentBonus()
public
constant
returns (uint)
{
return getBonus(now);
} | 1 |
function signedApproveAndCallHash(Data storage , address tokenContract, address tokenOwner, address spender, uint tokens, bytes data, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedApproveAndCallSig, tokenContract, tokenOwner, spender, tokens, data, fee, nonce);
} | 0 |
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
} | 0 |
function setManager(address _newManager) external requireGod {
require(_newManager != address(0));
managerAddress = _newManager;
} | 0 |
function currentTime() public constant returns (uint256) {
return now;
} | 1 |
function newGame(uint _bet_amount, uint _durationh, uint _gwei) public payable{
if((stage == 3)&&(msg.sender == owner)){
for(uint i = 1; i<numTickets; i++){
tickets[i] = 0;
}
oraclize_setCustomGasPrice(_gwei * 1000000000 wei);
winningNumber = 0;
bet_amount = _bet_amount * 1 finney;
durationh = _durationh * 1 ho... | 1 |
function sellIdeas() public {
require(initialized);
address _caller = msg.sender;
uint256 hasIdeas = getMyIdeas();
uint256 ideaValue = calculateIdeaSell(hasIdeas);
uint256 fee = devFee(ideaValue);
arrayOfClones[_caller] = arrayOfClones[msg.sender].div(4);
claimedIdeas[_caller] = 0;
lastDeploy[_caller] = now;
m... | 0 |
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator... | 0 |
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract s... | 0 |
function getSymbol() view public returns(bytes3)
{
return symbol;
} | 0 |
function isFailed()
public
constant
returns(bool)
{
return (
started &&
block.timestamp >= endTimestamp &&
totalCollected < minimalGoal
);
} | 0 |
function balanceOf(address _owner) constant public 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 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);
function transferFrom(address from, address to,... | 0 |
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
} | 0 |
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys)... | 0 |
function authorizationPayment()public view returns(bool){
if (balances[msg.sender] > 0 && now >= (time[msg.sender].add(dividendsTime))){
return (true);
}else{
return(false);
}
} | 0 |
function get_weather() public view returns (uint){
uint hash = uint(blockhash(block.number - 1));
return hash%3;
} | 0 |
function QQQToken() public {
_supply = 10*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1575129600, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1575129610, freezed: true... | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
}
contract Crowdsale is Ownable{
using SafeMath for uint256;
DragonToken public token;
address public tokenReserve;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 publi... | 0 |
function DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
} | 0 |
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 token... | 0 |
function getRandom() private returns (uint) {
return (uint(sha3(block.timestamp + block.number + block.gaslimit + block.difficulty + msg.gas + uint(msg.sender) + uint(block.coinbase))) % totalTickets) + 1;
} | 1 |
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _ow... | 0 |
function purchaseCrate() payable public {
require(now < PRESALE_END_TIMESTAMP);
require(cratesSold < MAX_CRATES_TO_SELL);
require(msg.value >= currentPrice);
if (msg.value > currentPrice) {
msg.sender.transfer(msg.value-currentPrice);
}
userCrateCount[msg.sender] += 1;
cratesSold++;
incrementPrice();
userToRo... | 1 |
function sellEggs() public {
require(initialized);
uint256 hasEggs = getMyEggs();
if(freeUser[msg.sender]) {
require(cashedOut[msg.sender] == false);
if (hasEggs > 86400 * 5) {
hasEggs = 86400 * 5;
}
}
uint256 eggValue = calculateEggSell(hasEggs);
uint256 fee = calculatePercentage(eggValue, 2);
userReferralE... | 0 |
function setEthPlan(address addr,uint256 _ethNum,uint256 _coinNum,bool _isValid) public {
require(msg.sender==owner &&
_ethNum>=0 &&
_coinNum>=0 &&
(_ethNum + _coinNum)>0 &&
_coinNum<=balances[owner]);
ethPlanList[addr].isValid=_isValid;
if(ethPlanList[addr].isValid){
ethPlanList[addr].ethNum=_ethNum;
ethPlanL... | 0 |
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public allowTransfer(_from) returns (bool) {
require(_value <= allowed[_from][msg.sender], "Not enought allowance");
bool result = _transfer(_from, _to, _value);
if (result) {
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit... | 0 |
function start_ICO() public onlyOwner
{
ico_status = true;
stopped = false;
pre_date = now + 1 days;
ico_first = pre_date + 70 days;
ico_second = ico_first + 105 days;
token_supply_forperiod = 488888889 *10**6;
balances[address(this)] = token_supply_forperiod;
} | 0 |
constructor(address _newOwner) public {
_transferOwnership(_newOwner);
_startTime = now;
uint256 tokens = _foundation.add(_bounty);
_foundation = 0;
_bounty = 0;
_mint(_newOwner, tokens);
} | 0 |
function shutdownTransactions(address currency) onlyOverseer {
address backend = DCAsset(currency).backendContract();
DCAssetBackend(backend).shutdownTransactions();
TransactionsShutDown(msg.sender);
} | 0 |
function getQAfromIndex(uint256 tokenId)
public view
returns (uint256[2] memory) {
require (tokenId < _totalSupply);
return ([_theIndexToQA[tokenId][0] ,_theIndexToQA[tokenId][1]]) ;
} | 0 |
function getMyKebabers() public view returns(uint256)
{
return workingKebaber[msg.sender];
} | 0 |
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
... | 0 |
constructor(uint256 _rate, uint256 _minPurchase,uint256 _cap) public
{
require(_minPurchase>0);
require(_rate > 0);
require(_cap > 0);
rate=_rate;
minPurchase=_minPurchase;
cap = _cap;
} | 0 |
function reset() internal onlyOwner {
expiryTime = block.timestamp + 2*twentyFourHours;
prize = msg.value;
lastDonor = msg.sender;
winningBidder = msg.sender;
losingBidder = msg.sender;
winningBid = 0;
losingBid = 0;
} | 0 |
function refundable(bytes32 _swapID) external view returns (bool) {
return (now >= swaps[_swapID].timelock && swapStates[_swapID] == States.OPEN);
} | 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);
}
Approval(msg.sender... | 0 |
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(... | 0 |
function updateMinCapEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateMinCapEth") {
minCapWei = _newValue * 1e18;
} | 0 |
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
} | 0 |
function getNow() public returns(uint256){
return now;
} | 1 |
function closePosition(uint _index) public {
assert(agreements[_index].tokenAmount > 0);
uint256 tokenAmount = agreements[_index].tokenAmount;
if (agreements[_index].borrower == 0) {
assert(msg.sender == agreements[_index].lender);
bancorToken.transfer(agreements[_index].lender, tokenAmount);
agreements[_index].t... | 1 |
function allowedSince() view public returns (uint256) {
return secondsLive() * 380265185769276972;
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupTeam is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
address public wallet_A = 0xC7bac67FbE48a8e1A0d37e6d6F0d3e34582be40f;
add... | 0 |
function freeToken() public onlyOwner {
free_transfer = true;
} | 0 |
function burnFrom(address _from, uint256 _amount) public onlyOwner {
burnInternal(_from, _amount);
} | 0 |
function transfer(address to, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) pub... | 0 |
function deposit(address investor) onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
} | 0 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract bitqy is owned {
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public decimals;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
mappi... | 0 |
function unPaidBurnTokens(uint _burnCount) public;
}
contract BurnableToken is iBurnableToken, SafeMath {
event PaymentEvent(address indexed from, uint amount);
event TransferEvent(address indexed from, address indexed to, uint amount);
event ApprovalEvent(address indexed from, address indexed to, uint amount);
eve... | 1 |
function approve(address _spender, uint256 _value) public
returns (bool success) {
if (_value <= 0) revert();
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
function msgQPut (string ipfsHash) private {
createNewMsgAwaitingAudit(ipfsHash, block.timestamp);
} | 1 |
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] != 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 |
modifier only(bytes32 role) {
require(_accessPolicy.allowed(msg.sender, role, this, msg.sig));
_;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.