function string | label int64 |
|---|---|
modifier onlyOwner() {
require(isOwner());
_;
} | 0 |
function plus(uint a, uint b) public pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
} | 0 |
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
} | 0 |
function AddTicket() public payable
{
require(msg.value == ticketPrice);
require(numtickets < maxTickets);
lastTicketTime = now;
numtickets += 1;
totalBounty += ticketPrice;
bool success = numtickets == maxTickets;
NewTicket(msg.sender, success);
if(success)
{
PayWinner(msg.sender);
}
} | 1 |
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function LimitedSetup(uint _setupDuration)
public
{
constructionTime = now;
setupDuration = _setupDuration;
} | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
icoRunningStatus= false;
_totalsupply = (_totalsupply).sub(balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
} | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
modifier onlyOwner() {
require((msg.sender == owner) || (msg.sender == ownerMaster), "Only owner");
_;
} | 0 |
function canUpgrade() public view returns(bool) {
return released && super.canUpgrade();
} | 0 |
function activeUnLockGMI(uint64 timeStamp) public isOwer() {
activatedTime = timeStamp;
activated_ = true;
} | 0 |
function setProfitAddress(address _profitAddress) onlyOwner external {
require(_profitAddress != address(0));
profitAddress = _profitAddress;
} | 0 |
function getBalance() public view returns (uint256) {
return address(this).balance;
} | 0 |
function setBackEndAddress(address newBackEndOperator) public onlyOwner {
backEndOperator = newBackEndOperator;
} | 0 |
function unpause() onlyOwner whenPaused public {
require(now > startTime + lockPeriod);
super.unpause();
} | 1 |
function frozen(address _target) view public returns (bool){
return frozenAccounts[_target];
} | 0 |
function name() pure public returns (string _name) {
return TOKEN_NAME;
} | 0 |
function publicSaleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
publicIssuedSale = pu... | 0 |
function balanceOf(address _address) constant returns (uint256 balance) {
return DCAssetBackend(backendContract).balanceOf(_address);
} | 0 |
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed_[_owner][_spender];
} | 0 |
function redeem(bytes32 _swapID, bytes32 _secretKey) external onlyOpenSwaps(_swapID) onlyWithSecretKey(_swapID, _secretKey) {
Swap memory swap = swaps[_swapID];
swaps[_swapID].secretKey = _secretKey;
swapStates[_swapID] = States.CLOSED;
redeemedAt[_swapID] = now;
swap.withdrawTrader.transfer(swap.value);
emit Log... | 0 |
function ChickenFarm() public{
ceoAddress = msg.sender;
} | 0 |
function beginLiquidation()
internal
{
liquidationTimestamp = now;
emit LiquidationBegun(liquidationPeriod);
} | 0 |
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
} | 0 |
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
} | 0 |
function fourth_release(uint256 balance) private atStage(Stages.fourthRelease) {
require(now > fourthRelease);
ERC20Token.transfer(beneficiary, balance);
} | 0 |
function finalizeVestingAllocation(uint _holdingPoolTokens) public onlyOwner {
additionalHoldingPool = _holdingPoolTokens;
vestingStarted = true;
vestingStart = now;
} | 0 |
function withdraw(uint amount) public {
require(time() > withdrawTimes[msg.sender], "Governance::withdraw: Voters with an active proposal cannot withdraw");
deposits[msg.sender] = deposits[msg.sender].sub(amount);
require(token.transfer(msg.sender, amount), "Governance::withdraw: Transfer failed");
} | 0 |
function BlockbidCrowdsale(uint _goal, uint _cap, uint _startTime, uint _endTime, uint _rate, uint _earlyBonus, address _wallet)
Crowdsale(_startTime, _endTime, _rate, _wallet) public {
require(_cap > 0);
require(_goal > 0);
standardrate = _rate;
earlybonus = _earlyBonus;
cap = _cap;
goal = _goal;
} | 0 |
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) internal balances;
uint256 internal totalSupply_;
function totalSupply() public ... | 0 |
function mint(Data storage self, address tokenOwner, uint tokens, bool lockAccount) public returns (bool success) {
require(self.mintable);
require(msg.sender == self.minter || msg.sender == self.owner);
if (lockAccount) {
self.accountLocked[tokenOwner] = true;
}
self.balances[tokenOwner] = safeAdd(self.balances[... | 0 |
modifier canTransfer(address _sender, uint _value) {
if (_value > transferableTokens(_sender, uint64(now))) throw;
_;
} | 0 |
function addParticipant(address _buyer, uint256 _value) internal {
require(_value == priceCarnita || _buyer== addressManager);
function () onContractRunning payable public {
addParticipant(msg.sender, msg.value);
}
} | 0 |
function calculateReward(uint256 ethValue) private view returns (uint256 amount) {
uint256 baseQuotient = 1000;
uint256 actualQuotient = baseQuotient.add(calculateBonusTierQuotient());
uint256 reward = ethValue.mul(PARSECS_PER_ETHER_BASE);
reward = reward.mul(actualQuotient);
reward = reward.div(baseQuotient);
re... | 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, uint25... | 0 |
function _transfer(address _from, address _to, uint256 _value) internal
{
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to].add(_value) > balanceOf[_to]);
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] =... | 0 |
function TRMCrowdsale(){
owner = msg.sender;
token = ERC20(addressOfERC20Token);
ETHUSDdemon = msg.sender;
} | 0 |
function withdraw(address _to, uint256 _value) public {
require(_to != address(0));
require(_value > 0);
require(unFreezeStartDate < now, "not unfrozen yet");
require(
(getUnfrozenAmount(msg.sender).sub(withdrawnBalances[msg.sender]))
>= _value
);
withdrawnBalances[msg.sender] = withdrawnBalances[msg.sender].ad... | 0 |
function freeze(address account) external only(freezer) {
require(data.frozenTime(account) == 0, "account already frozen");
data.setFrozenTime(account, now);
emit Frozen(freezer, account);
} | 0 |
modifier onlyAdmin() {
require(admins[msg.sender]);
_;
} | 0 |
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PitEur is Ownable, ERC20 ... | 0 |
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
} | 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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256)... | 0 |
function atNow() public constant returns (uint) {
return now;
} | 1 |
function setUpgradeMaster(address master) public {
require(master != 0x0);
require(msg.sender == upgradeMaster);
upgradeMaster = master;
} | 0 |
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
} | 0 |
function PreICO(address _token, uint256 _endTime, address _wallet) public {
require(_token != address(0));
require(_wallet != address(0));
require(_endTime > now);
token = Showcoin(_token);
wallet = _wallet;
endTime = _endTime;
} | 0 |
function seedMarket(uint256 eggs) public payable {
require(marketEggs==0);
initialized=true;
marketEggs=eggs;
contractStarted = now;
} | 0 |
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) public returns (bool success) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function finalization() internal {
token.transfer(owner, token.balanceOf(this));
} | 0 |
function calcprice() view private returns (uint){
uint price_tokn;
if(ETHcollected <= 246153 ether){
price_tokn = 40625;
}
else if(ETHcollected > 246153 ether){
price_tokn = 30111;
}
return price_tokn;
} | 0 |
function hashEIP712Message(bytes32 hashStruct)
internal
view
returns (bytes32 result)
{
bytes32 eip712DomainHash = EIP712_DOMAIN_HASH;
assembly {
let memPtr := mload(64)
mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000)
mstore(add(memPtr, 2), eip712DomainHash)
mstore(add(memPt... | 0 |
function stopTransferToken() external onlyOwner {
require(!lockstatus, "Token is locked");
lockstatus = true;
} | 0 |
function isVestingSet(address adr) public view returns (bool isSet) {
return vestingMap[adr].amount != 0;
} | 0 |
function allowance(address owner, address spender) public constant returns (uint256);
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 va... | 0 |
function vaultRequestFromUser () external canPoSMint returns (string memory message) {
uint256 amountAllowed = _remoteToken.allowance(msg.sender, _vaultAddress);
require(amountAllowed > 0, "No allowance has been set.");
require(amountAllowed <= _stakeMaximum, "The allowance has been set too high.");
uint256 amountB... | 0 |
function balanceOf(address who)public view returns (uint256);
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(ad... | 0 |
function invest()
{
if (msg.value<setting_minInvestment) throw;
bool alreadyInvestor;
openPosition=255;
cheapestUnlockedPosition=255;
minCurrentInvest=1000000000 ether;
updateBalances();
for (uint8 k = 0; k<setting_maxInvestors; k++)
{
if (investors[k].investor==0) openPosition=k;
else if (investors[k].inves... | 0 |
function setIcoAddress(address _ico) public onlyOwner {
require(_ico != address(0));
require(balanceOf(addressIco) == 0);
addressIco = _ico;
transferOwnership(_ico);
} | 0 |
function tridentReward(address owner) public view returns (uint256 totalReward) {
require(_transferIns[owner].amountInVault > 0, "You have not sent any tokens into stake.");
uint256 _amountInStake = _transferIns[owner].amountInVault;
uint _lengthOfHoldInSeconds = _holdAgeTimestamp(owner);
if (_lengthOfHoldInSeconds... | 0 |
function addBlackList(address _to) onlyOwner public
{
require(blackLists[_to] == false);
blackLists[_to] = true;
} | 0 |
function setupTimeWindow(uint256 secs) onlyOwnerUnlocked setter {
timeWindow = secs;
} | 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 constant returns (uint256);
function transferFrom(address from, address to, uint256 v... | 0 |
function updateEtherBalance() public {
targetCrowdsale.withdrawEther();
} | 0 |
function checkIfFundingCompleteOrExpired() public {
if (totalDistributed.add(totalBonusDistributed) > hardCap.sub(rate)) {
state = State.Successful;
completedAt = now;
emit LogFundingSuccessful(totalRaised);
finished();
}
} | 0 |
function assert(bool assertion) internal {
if (!assertion) throw;
} | 0 |
function allowance(address _owner, address _spender)
public view returns (uint256);
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,
u... | 0 |
function getNow() constant returns (uint result){
return now;
} | 1 |
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityTo... | 0 |
function transferFrom(address from_, address to_, uint value_) external returns (bool);
}
contract BaseICO is Ownable, Whitelisted {
enum State {
Inactive,
Active,
Suspended,
Terminated,
NotCompleted,
Completed
} | 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 enableTransfers() public {
data.enableTransfers();
} | 0 |
function tradeInternal(Order left, bytes32 leftHash, Order right, bytes32 rightHash) internal {
uint256 priceNumerator;
uint256 priceDenominator;
uint256 leftAmountRemaining;
uint256 rightAmountRemaining;
uint256 amountBaseFilled;
uint256 amountQuoteFilled;
uint256 leftFeePaid;
uint256 rightFeePaid;
require(le... | 0 |
modifier onlyDestroyer() {
require(msg.sender == destroyer);
_;
} | 0 |
constructor() public {
ceoAddress=msg.sender;
} | 0 |
function pause() public onlyOwner {
stopTime = now + stopTimeLength;
} | 0 |
function transfer(uint128 assetAmount, bytes16 lockID, uint32 event_id) onlyIssuer returns (bool success) {
if(matured==false){
uint128 lockAmount;
bytes32 currencyAndBank;
address executingBond;
address lockFrom;
transferBond[lockID].assetAmount = assetAmount;
transferBond[lockID].event_id = event_id;
Escrow e... | 0 |
function add(address _owner, uint16 _species, uint8 _subSpecies, uint8 _eyeColor) external onlyCaller {
Creature memory _creature = Creature({
species: _species,
subSpecies: _subSpecies,
eyeColor: _eyeColor,
timestamp: uint64(now)
});
uint256 newCreatureID = creatures.push(_creature) - 1;
transfer(0, _owner, ne... | 1 |
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function transfer(address to, uint256 value, bytes data) returns (bool);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInter... | 0 |
function makeContractPermanent(string _name) onlyOwner public returns (bool) {
require(contracts[_name].contractAddress != address(0x0));
require(contracts[_name].isPermanent == false);
contracts[_name].isPermanent = true;
ContractMadePermanent(_name);
return true;
} | 0 |
function withdrawPUB() public returns(bool){
require(block.timestamp>pubEnd);
require(sold[msg.sender]>0);
bool result=token.call(bytes4(keccak256("transfer(address,uint256)")), msg.sender, sold[msg.sender]);
delete sold[msg.sender];
return result;
} | 0 |
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXSB is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decima... | 0 |
function cancelOrderInternal(Order memory order)
internal
{
OrderInfo memory orderInfo = getOrderInfo(order);
assertValidCancel(order, orderInfo);
updateCancelledState(order, orderInfo.orderHash);
} | 0 |
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) ... | 0 |
function mint(address player, uint256 amount)
private
{
uint256 amountToMint;
if(totalSupply.add(amount) < MAX_SUPPLY) {
amountToMint = amount;
} else {
amountToMint = MAX_SUPPLY.sub(totalSupply);
minting = false;
}
Shareholder storage minter = shareholders[player];
Shareholder storage dev = shareholders[DEV... | 0 |
function reject(uint256 idx) public isManager {
assert(contributors[idx].addr != 0);
assert(!contributors[idx].rejected);
isWhitelisted[contributors[idx].addr] = false;
contributors[idx].rejected = true;
contributors[idx].addr.transfer(contributors[idx].amount);
} | 1 |
function manualUpdateBalances()
expireGambles
noEthSent
onlyDeveloper
{
updateBalances();
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances_[msg.sender]);
balances_[msg.sender] = balances_[msg.sender].sub(_value);
balances_[_to] = balances_[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function mint(address account, uint256 amount) external onlyOwner {
require(saleBeginTime < block.timestamp);
require(saleEndTime > block.timestamp);
_transfer(address(this), account, amount);
emit Mint(account, amount, _amountForSale);
} | 0 |
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
} | 0 |
modifier onlyRole(string roleName)
{
checkRole(msg.sender, roleName);
_;
} | 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 transfer(address to, uint value) returns (bool ok);
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, add... | 0 |
function sha(uint128 wager) constant private returns(uint256)
{
return uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, wager));
} | 1 |
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
} | 0 |
function isAllocationLocked(address _spender) constant returns (bool)
{
return inAllocationLockPeriod() && isTeamMember(_spender);
} | 0 |
function changeFeeOwner(address _feeOwner) onlyOwner public {
require(_feeOwner != feeOwner && _feeOwner != address(0));
feeOwner = _feeOwner;
} | 0 |
function name() external view returns (string) {
return string(name_);
} | 0 |
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1CHICKEN, SafeMath.sub(now, lastHatch[adr]));
return SafeMath.mul(secondsPassed, hatcheryCHICKEN[adr]);
} | 0 |
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.