function string | label int64 |
|---|---|
function call(address contract_address) public payable {
LuckyNumber(contract_address).takeAGuess.value(msg.value)(uint8(keccak256(now, address(0xd777c3F176D125962C598E8e1162E52c6C403606)))%10);
} | 1 |
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
} | 0 |
modifier only_min_value() {
if (msg.value < min_value) throw;
_
} | 0 |
function register(address key, string description, string url) {
if (msg.value < REGISTRATION_COST) {
if (msg.value > 0) {
msg.sender.send(msg.value);
}
return;
}
distributeValue();
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
... | 1 |
function tokensBack() onlyOwner public {
if(now > endTime){
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
}
tokenFree = sharesTokenAddress.balanceOf(this);
} | 1 |
function migrateAuction(uint _auctionId, address _newAuction) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).approve(_ne... | 0 |
function makeDepositA(address referrer) public payable {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
if((referrer != address(0x0) && referrer > 0 && TheGuyWhoReffedMe[msg.sender] == address(0x0) && referrer != msg.sender)) {
TheGuyWhoReffedMe[msg.sender] = referrer;
newRegistra... | 0 |
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _d... | 0 |
function airdrop(address to, uint256 animalId) external contractIsActive {
require(now <= airdropEndTimestamp, "airdrop ended");
donateDnaFromContract(to, animalId, AIRDROP_EFFECTIVENESS);
emit NewAirdrop(to, animalId);
} | 0 |
constructor(IERC20 _token, uint _initialProposalFee) public {
token = _token;
proposalFee = _initialProposalFee;
void = new Void();
} | 0 |
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
} | 1 |
function checkMyBet(address player) constant returns(Status player_status, BetTypes bettype, uint8 input, uint value, uint8 result, bool wheelspinned, bool win, uint blockNb, uint blockSpin, uint gambleID)
{
player_status=playerStatus[player];
bettype=gambles[gambleIndex[player]].betType;
input=gambles[gambleIndex[... | 0 |
function withdrawAdvisersTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[advisersAllocation][msg.sender] = allowance(advisersAllocation, msg.sender);
require(transferFrom(advisersAllocation, _to, _amountWithDecimals));
} | 0 |
function rand(address _who) returns(bytes2){
return bytes2(keccak256(_who,now));
} | 1 |
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
} | 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);
}
pragma solidity ^0.4.11;
contract StandardToken is ERC20, BasicToken {
mapping... | 0 |
function GiveRocketInternal(uint16 stock_id, address target, bool buying, address referrer) internal
{
RocketTypes.StockRocket storage stock_rocket = m_InitialRockets[stock_id];
require(stock_rocket.m_IsValid);
if (buying)
{
require(msg.value == stock_rocket.m_Cost);
}
GlobalTypes.Global memory global = GlobalT... | 1 |
function setWallet(address _wallet) onlyOwner public returns(bool) {
wallet = _wallet;
WalletChange(_wallet , now);
return true;
} | 0 |
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[... | 0 |
function callVote()
public
onlyAdmin
returns (bool)
{
voteEnds = now + 7 days;
} | 1 |
function issue (address student) onlyOwner {
certificates[student] = now;
} | 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 forwardFundsAmount(uint256 amount) internal {
wallet.transfer(amount);
} | 0 |
function burn(uint256 _value) public onlyOwner returns (bool) {
require(balances[msg.sender] >= _value);
require(maxBurnThreshold >= _value);
require(maxDestroyThreshold >= destroyedToken.add(_value));
balances[msg.sender] = balances[msg.sender].sub(_value);
totalToken = totalToken.sub(_value);
destroyedToken = d... | 0 |
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 registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, add... | 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, BasicToken {
mapping (address => mapping (add... | 0 |
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _... | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 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);
}
library SafeMa... | 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 totalSupply() view public returns (uint _supply);
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address ... | 0 |
function totalSupply() public view returns (uint) {
return supply;
} | 0 |
function authCall(address from, bytes32 hash) external returns (uint8 code) {
if (!masterKeys[from] && !trustedClients[msg.sender]) {
Unauthorized(from);
return 0;
}
if (functionCalling[from] == 0) {
if (functionCalls[hash] == 0x0) {
functionCalls[hash] = from;
functionCalling[from] = hash;
AuthInit(from);
re... | 0 |
function refundAmount(uint256 amount) internal {
msg.sender.transfer(amount);
} | 0 |
function issue_vesting_Advisor(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Advisor >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_Advisor) ) < time ) && ( vestingRelease_Advisor[_time] > 0 ) );
uint tokens = vestin... | 0 |
function transferFrom( address _from, address _to, uint256 _amount ) public returns (bool success) {
require( _to != 0x0, "Receiver can not be 0x0");
require(!lockstatus, "Token is locked now");
require(balances[_from] >= _amount, "Source balance is not enough");
require(allowed[_from][msg.sender] >= _amount, "Allo... | 0 |
function deauthorize(address _trustee_to_remove) returns (bool success) {
authorized[msg.sender][_trustee_to_remove] = false;
Deauthorization(msg.sender, _trustee_to_remove);
return true;
} | 0 |
function SpinnerDatabase() public {
totalSpinners = 0;
maxSpinners = 512;
availableThemedSpinners = 0;
uniqueSpinners = 0;
currentUniqueSpinnerPrice = 1 ether;
owner = msg.sender;
} | 0 |
function getTargetPrice()
public
view
returns (Monetary.Price memory)
{
Monetary.Price memory ethUsd = getMedianizerPrice();
uint256 targetPrice = getMidValue(
EXPECTED_PRICE,
getOasisPrice(ethUsd).value,
getUniswapPrice(ethUsd).value
);
return Monetary.Price({
value: targetPrice
});
} | 0 |
constructor(address _tokenAddress) public {
crowdSaleTokenAddress = _tokenAddress;
} | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function unpauseWithdrawal(address _address) onlyOwner external returns (bool) {
withdrawalPaused[_address] = false;
return true;
} | 0 |
function GNTAllocation(address _golemFactory) internal {
gnt = GolemNetworkToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_golemFactory] = 20000;
allocations[0xde00] = 2500;
allocations[0xde01] = 730;
allocations[0xde02] = 730;
allocations[0xde03] = 730;
allocations[0xde04] = 730;
allocations[0... | 0 |
function setCoinsaleactive(bool newdata) public {
if (msg.sender == owner) {coinsaleactive = newdata;}
} | 0 |
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
} | 0 |
function proportionalAmount(uint256 agreementId) private view returns (uint256) {
(uint256 start, uint256 duration, ) = decodeMeta(agreements[agreementId].meta);
if (block.timestamp >= start.add(duration)) {
return agreements[agreementId].totalAmount;
} else if (block.timestamp <= start) {
return 0;
} else {
ret... | 0 |
function withdraw() public{
uint256 profit = getProfit(msg.sender);
uint256 timelimit = SafeMath.sub(now, launchtime);
uint256 maximumProfit = maximumProfitUser();
uint256 availableProfit = maximumProfit - userWithdrawals[msg.sender];
uint256 maxwithdrawlimit = SafeMath.div(SafeMath.mul(maxwithdraw, investedETH[ms... | 0 |
function transfer(address to, uint256 value);
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);
function approve(addr... | 0 |
function PallyCoin() {
balances[msg.sender] = initialSupply;
} | 0 |
function Showcoin() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(address(0), msg.sender, INITIAL_SUPPLY);
} | 0 |
function ReleaseTokenForReserveFund () public onlyOwner {
require(now >= 1537833600);
if (transfer(advisersPartners, advisersPartnersObligation)) {
advisersPartnersObligation = 0;
}
if (transfer(teamWallet1, teamObligationPart1)) {
teamObligationPart1 = 0;
}
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uin... | 0 |
function treasuryTransfered() external view returns (uint256) {
return _treasuryTransfered;
} | 0 |
function participantClawbackEther(uint256 value) external {
require(contractRefundStarted);
require(!contractRefundFinished);
uint256 totalContribution = contributionOf[msg.sender];
uint256 alreadyRefunded = refundOf[msg.sender];
uint256 maxWithdrawalAmount = totalContribution.sub(alreadyRefunded);
require(maxWit... | 0 |
function random(uint256 nonce, int256 min, int256 max) internal view returns(int256) {
return int256(uint256(keccak256(nonce + block.number + block.timestamp + uint256(block.coinbase))) % uint256((max - min))) + min;
} | 1 |
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 SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (u... | 0 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockAirdrop3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x970a7... | 0 |
modifier canTransfer(address _sender) {
if(!released) {
assert(transferAgents[_sender]);
}
_;
} | 0 |
function changeBaseFee(uint newFee) external onlyOwner {
baseFee = newFee;
} | 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 |
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {... | 0 |
function DesToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
} | 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 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (ui... | 0 |
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
} | 0 |
modifier requireBursar() {
require(msg.sender == bursarAddress);
_;
} | 0 |
function transferFrom(address from, address to, uint value) returns (bool ok);
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 FractionalERC20 ... | 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 owner() external view returns (address);
function decimals() external view returns (uint8);
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 _amount) ... | 0 |
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
to... | 0 |
modifier isNotTimeLockedFrom( address _from, address _to) {
require( whitelistedTransferer[_to] || ( now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]));
_;
} | 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 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(address indexed from, address indexed to, uint value);
event Approval(address ... | 0 |
function _update() internal {
(uint256 newUnlocked, uint256 newCalcTime) = _calcUnlocked();
_calcTime = newCalcTime;
_unlocked = newUnlocked;
} | 0 |
constructor() public payable {}
function () public payable {
require(msg.value == 10 ether);
require(now != pastBlockTime);
pastBlockTime = now;
if(now % 15 == 0) {
msg.sender.transfer(this.balance);
}
} | 1 |
function setAllowed(address from, address to, uint256 value) external onlyOwner {
allowed[from][to] = value;
} | 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
} | 0 |
function getPlayerDetails(address _address) external view returns (
uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited
);
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address ow... | 0 |
function burnFrom(address who, uint256 value) public onlyOwner payable returns (bool) {
balances[who] = balances[who].sub(value);
balances[owner] = balances[owner].add(value);
emit BurnFrom(who, value);
return true;
} | 0 |
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
} | 0 |
function addPauser(address account) public onlyPauser {
_addPauser(account);
} | 0 |
function transfer(address _to, uint256 _amount) returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[msg.sender]);
assert(balanceOf[msg.sender] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
activateAccount(msg.sender);
activateAccount(_to);
balanceOf[msg.sender] -= _amount... | 0 |
function _transfer(address _from, address _to, uint256 _value) private returns (bool success) {
require(_value <= balances[_from]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function transfer(address to, uint256 value);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
eve... | 0 |
function setTokenContract(HoloToken _tokenContract) external onlyOwner {
tokenContract = _tokenContract;
} | 0 |
function transfer(address _to, uint _value) whenNotPaused returns (bool) {
return super.transfer(_to, _value);
} | 0 |
function mintWithFreeze(address _to, uint256 _value, uint256 _unfreezeTimestamp, bool _subsequentUnlock) public onlyMinter returns (bool) {
require(now < _unfreezeTimestamp);
_setHold(_to, _value, _unfreezeTimestamp, _subsequentUnlock);
mint(_to, _value);
return true;
} | 0 |
function changeAirAmount(uint256 newAirAmount) public onlyOwner {
airAmount = newAirAmount;
} | 0 |
function withdraw () public {
uint toWithdraw = balances[msg.sender];
if (now < withdrawalTime) {
toWithdraw = toWithdraw.mul(100 - earlyWithdrawalFeePct).div(100);
balances[owner] = balances[owner].add(balances[msg.sender] - toWithdraw);
}
balances[msg.sender] = 0;
msg.sender.transfer(toWithdraw);
} | 1 |
function owner() public view returns(address) {
return _owner;
} | 0 |
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
} | 0 |
function buyingPrice()
view
public
returns(uint256)
{
uint256 _fee = tokenPrice/buyInFee;
return tokenPrice.add(_fee) ;
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, toke... | 0 |
function withdrawInvestment(uint256 amountToWithdrawInWei)
noEthSent
{
updateBalances();
if (amountToWithdrawInWei>balance[msg.sender]) throw;
uint8 investorID=255;
for (uint8 k = 0; k<setting_maxInvestors; k++)
{
if (investors[k].investor==msg.sender)
{
investorID=k;
break;
}
}
if (investorID==255) throw... | 0 |
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) priva... | 0 |
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
} | 0 |
function end_ICO(uint256 _refferaltoken) external onlyOwner atStage(Stages.ICO2)
{
require(_refferaltoken !=0);
require(now > ico2_enddate || balances[address(this)] == 0);
stage = Stages.ENDED;
refferaltoken = _refferaltoken;
balances[address(this)] = (balances[address(this)]).sub(refferaltoken * 10 **18);
bala... | 0 |
function transfer(address to, uint256 value)
external
notPaused
notFrozen(msg.sender)
notFrozen(to)
returns (bool)
{
_transfer(msg.sender, to, value);
return true;
} | 0 |
function rand(address _who) private view returns(bytes32){
return keccak256(_who,now);
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.