function string | label int64 |
|---|---|
modifier onlyOwner() {
if(msg.sender == owner) _;
} | 0 |
function getTimestamp() view public returns (uint256) {
return now;
} | 1 |
constructor () public {
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
} | 0 |
function transfer(address _to, uint _value) returns(bool) {
if (now < presaleDeadline) {
require(assetProxy.transferFrom(msg.sender, address(this), _value));
require(vesting.createVesting(_to, assetProxy, _value, 1, paymentInterval, schedule));
return true;
}
return assetProxy.transferFrom(msg.sender, _to, _value... | 0 |
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, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spend... | 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(owner, refund);
Revoked();
} | 0 |
function underLimit(uint256 _value) internal returns (bool) {
if (today() > lastDay_[msg.sender]) {
spentToday_[msg.sender] = 0;
lastDay_[msg.sender] = today();
}
if (spentToday_[msg.sender] + _value >= spentToday_[msg.sender] && spentToday_[msg.sender] + _value <= dailyLimit_) {
spentToday_[msg.sender] += _value... | 0 |
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
} | 0 |
function isLocked() returns (bool status) {
return locked;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public;
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20Old is ERC20OldBasic {
function allowance(address owner, address spender) public view returns (uint256);
functi... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(a... | 0 |
function isActive()
public
constant
returns(bool)
{
return (
started && !completed
);
} | 0 |
function SATCoin() public
{
owner = msg.sender;
balances[owner] = 350000000 * 10 **8;
balances[address(this)] = 650000000 *10**8;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, owner, balances[address(this)]);
} | 0 |
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
uint256 reserveTokens = 400000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
} | 0 |
function isFinalizerSane() public constant returns (bool sane) {
return address(finalizeAgent) == 0 || finalizeAgent.isSane(token);
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
function currentTime() constant returns (uint _currentTime) {
return now;
} | 1 |
function SATCoin() public
{
owner = msg.sender;
balances[owner] = 350000000 * 10 **8;
balances[address(this)] = 650000000 *10**8;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, owner, balances[address(this)]);
} | 0 |
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(... | 0 |
function hasActiveBet(address player)
public
view
returns(bool)
{
return bets[player].isOpen;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MplusCrowdsaleA {
using SafeMath for uint256;
uint256 internal constant NUM_STAGE... | 0 |
function treasuryAddress () external view onlyOwner returns (address treasury) {
treasury = _treasury;
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 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 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 returns (bool success);
function allowance(address owner, address spender) public view retu... | 0 |
function transfer(address to, uint256 value) public;
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20Old is ERC20OldBasic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public;... | 0 |
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
} | 0 |
modifier atStage(Stages _stage) {
require (stage == _stage);
_;
} | 0 |
function approve(address spender, uint tokens) public whenNotPaused returns (bool) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
} | 0 |
function balanceOf(address owner) public view returns (uint256 _balance);
function ownerOf(uint256 tokenID) public view returns (address owner);
function transfer(address to, uint256 tokenID) public returns (bool);
function approve(address to, uint256 tokenID) public returns (bool);
function takeOwnership(uint256 t... | 0 |
function burn(uint256 _amount) public {
burnInternal(msg.sender, _amount);
} | 0 |
function currentBlock() private constant returns(uint256 _currentBlock) {
return block.number;
} | 0 |
function getIssuer() constant returns (address _issuer) {
return issuer;
} | 0 |
function revoke(address wlCandidate) public onlyOwner {
whitelist[wlCandidate] = false;
emit Revoked(wlCandidate, now);
} | 0 |
constructor() public {
creationTime = now;
} | 0 |
constructor(ERC20Interface _addressOfTokenUsedAsReward) public {
tokenReward = _addressOfTokenUsedAsReward;
owner = 0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98;
beneficiary = 0x8605409D35f707714A83410BE9C8025dcefa9faC;
emit LogFundingInitialized(owner);
} | 0 |
function setBackend(address _backendContract) multisig(sha3(msg.data)) {
backendContract = _backendContract;
} | 0 |
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
} | 0 |
function allowTransfersTo(address _owner) onlyOwner {
allowedTransfersTo[_owner] = true;
} | 0 |
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function addEntry(string name, string company, string description, string category, string contact, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, contact, ethAddress, block.timestamp, false);
directory[ethA... | 1 |
function cancelOrderInternal(LibOrder.Order memory order)
internal;
function updateFilledState(
LibOrder.Order memory order,
address takerAddress,
bytes32 orderHash,
uint256 orderTakerAssetFilledAmount,
LibFillResults.FillResults memory fillResults
)
internal;
function updateCancelledState(
LibOrder.Order me... | 0 |
constructor() public
{
master = msg.sender;
} | 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);
emit Burn(burner, _value);
emit Transfer(burner, 0x0, _value);
} | 0 |
function unlock() public {
if(now < unlockedAt) throw;
if(!teamMultisig.send(address(this).balance)) throw;
Unlocked();
} | 1 |
function seedMarket(uint256 eggs) public payable{
require(marketEggs == 0 && msg.sender == ceoAddress);
initialized = true;
marketEggs = eggs;
} | 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) public balances;
function transfer(address _to, uint256 _value) public returns (b... | 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 thisweek() internal view returns (uint256) {
return now / 1 weeks;
} function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
function transferBalance(address upContract) external onlyControl {
require(upContract != address(0) && ... | 1 |
function balanceOf(address _owner) public view returns (uint256) {
return balances_[_owner];
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 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 BetGame(address _pls)
{
initializeTime = now;
roundCount = 1;
pls = ERC20(_pls);
} | 1 |
function releaseLockedTokens() external {
releaseLockedTokensFor(msg.sender);
} | 0 |
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 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 = 157500000e18;
bonusInPhase1 = 20;
bonusInPha... | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a / b;
return c;
} | 0 |
function getjournalists() view public returns(address[] memory) {
return listofjournalists;
} | 0 |
function pullFunds()
external
onlyOwner
returns (bool)
{
IBrickblockToken bbk = IBrickblockToken(
registry.getContractAddress("BrickblockToken")
);
uint256 _companyFunds = bbk.balanceOf(address(bbk));
return bbk.transferFrom(address(bbk), address(this), _companyFunds);
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
assert(b <= a);
return a - b;
} | 0 |
function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
address owner = ownerOf(_tokenId);
require(_to != owner);
if (approvedFor(_tokenId) != 0 || _to != 0) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
} | 0 |
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 transfer(address _to, uint256 _value) public returns (bool success) {
return _transfer(msg.sender, _to, _value);
} | 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 time() constant returns (uint) {
if(cTime > 0) {
return cTime;
}
return block.timestamp;
} | 1 |
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
} | 0 |
function deposit(bytes32 _password) public payable {
require(msg.value > commissionFee);
uint256 rand = _rand();
bytes32 pass = sha3(_password, rand);
randToAddress[msg.sender] = rand;
password[pass].from = msg.sender;
password[pass].amount = password[pass].amount.add(msg.value);
_updateSeed();
emit LogDeposit(... | 0 |
function feeRate() public view returns (uint16){
return _feeRate;
} | 0 |
function changeTokenInfo(uint16 tokenCode, address tokenContract) external onlyRegistryOwner() {
require (tokenCode != 0,
"Token code of zero is reserved for Ether.");
require (tokenContracts[tokenCode] == address(0),
"Token contract address can be assigned only once.");
tokenContracts[tokenCode] = tokenContract... | 0 |
function totalSupply() constant returns (uint256 balance) {
return DCAssetBackend(backendContract).totalSupply();
} | 0 |
function privateSaleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
require(maxPrivateSaleSupply >= privateIssuedSale.add(tokens));
require(tokens > 0);
for(uint i = 0; i < privateSaleLockTime; i++)
{
uint lockPer = 20;
if(i ... | 0 |
function weiAllowedToReceive(uint tentativeAmount, uint weiRaised, uint weiInvestedBySender, uint weiFundingCap) public constant returns (uint) {
uint totalOfSender = tentativeAmount.add(weiInvestedBySender);
if (totalOfSender > weiLimitPerAddress) tentativeAmount = weiLimitPerAddress.sub(weiInvestedBySender);
if (w... | 0 |
function MplusCrowdsaleA(address _tokenAddress, address _wallet) public {
require(_tokenAddress != address(0));
require(_wallet != address(0));
owner = msg.sender;
tokenOwner = msg.sender;
wallet = _wallet;
tokenReward = ERC20(_tokenAddress);
} | 0 |
function time() public constant returns (uint) {
return now;
} | 1 |
function reinvestProfit() public {
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
userWithdrawals[msg.sender] += profit;
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], profit);
} | 0 |
function transferOwnership(address newOwner) external onlyOwner
{
require( newOwner != 0x0);
balances[newOwner] = (balances[newOwner]).add(balances[owner]);
balances[owner] = 0;
owner = newOwner;
emit Transfer(msg.sender, newOwner, balances[newOwner]);
} | 0 |
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
} | 0 |
function giveBackOwnership(address _wallet)
public {
token.transferOwnership(_wallet);
} | 0 |
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value... | 0 |
modifier canBuy(address _address) {
bool found = false;
uint256 length = supportedERC20Token.length;
for (uint256 i = 0; i < length; i++) {
if (supportedERC20Token[i] == _address) {
require(block.timestamp > starttime[_address]);
require(block.timestamp < endtime[_address]);
found = true;
break;
}
}
require ... | 0 |
function Ownable() public {
ownerOne = msg.sender;
ownerTwo = msg.sender;
} | 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 allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
modifier whenActivated() {
require(isActivated || whitelistedBeforeActivation[msg.sender]);
_;
} | 0 |
constructor() internal {
owner = msg.sender;
startdate = now;
} | 0 |
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
b... | 0 |
function SATCoin() public
{
owner = msg.sender;
balances[owner] = 350000000 * 10 **8;
balances[address(this)] = 650000000 *10**8;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, owner, balances[address(this)]);
} | 0 |
function StartICO() external onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
enddate = now.add(39 days);
} | 0 |
function getRate()
public
view
returns(uint256)
{
return weiPerUnitRate;
} | 0 |
function lessThanSupply(uint256 amount, Day today) internal pure returns (bool) {
return today.soldFromUnreserved.add(amount) <= today.supply.sub(today.reserved);
} | 0 |
function mintPresaleTokens(address _investor, uint256 _value) internal {
require(icoState == IcoState.Presale);
require(_value > 0);
uint256 _elcValue = getPresaleTotal(_value);
uint256 timeBonusAmount = _elcValue * getTimeBonus(now) / 1000;
_elcValue += timeBonusAmount;
require(elc.totalSupply() + _elcValue <= t... | 1 |
constructor() public {
token = ERC20Basic(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
beneficiary = 0x439f2cEe51F19BA158f1126eC3635587F7637718;
releaseTime = now + 30 days;
} | 0 |
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
} | 0 |
constructor(address _oracle, address _depositor, address _beneficiary) public payable Ownable() {
oracle = IOracle(_oracle);
depositor = _depositor;
beneficiary = _beneficiary;
contractExecuted = false;
expiration = now + TO_EXPIRE;
} | 0 |
function symbol() constant returns (string) {
return _symbol;
} | 0 |
function tokenFallback(address, uint, bytes) public {
revert();
} | 0 |
function airdrop(address to, uint256 animalId) external;
function giveaway(
address to,
uint256 animalId,
uint8 effectiveness
)
external;
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address inde... | 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 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.