function string | label int64 |
|---|---|
function setPrice(uint256 _value) public onlyOwner{
tokenPrice=_value;
} | 0 |
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);
event Approval(address indexed owner, address inde... | 0 |
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 SATCoin is ERC20
{ using SafeMath for uint256;
string public constant name = "SATCoin";
stri... | 0 |
function allowance(address owner, address spender) constant returns (uint);
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... | 0 |
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * 2);}
} | 0 |
function devFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount,4),100);
} | 0 |
function random(uint64 upper) public returns (uint64 randomNumber) {
_seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
return _seed % upper;
} | 1 |
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
} | 0 |
function MiningRigFarmer() public{
ceoAddress=msg.sender;
} | 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);
}
contract Claim... | 0 |
function init(uint _startDate, uint _duration, uint8 _subject) private {
require(!inProgress());
require(_startDate >= now);
require(_subject > 0 && _subject <= 100);
currentVoting += 1;
startDate = _startDate;
endDate = _startDate + _duration;
votesYes = 0;
votesNo = 0;
subject = _subject;
emit InitVoting(_s... | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
return false;
} | 0 |
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeon... | 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 beneficiary() public view returns(address) {
return _beneficiary;
} | 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 Crowdsale is Ownable {
using SafeMath for uint256;
ERC20 public toke... | 0 |
function close() external onlyOwner {
crowdsaleActive = false;
isCrowdsaleClosed = true;
token.transfer(owner, token.balanceOf(address(this)));
emit Close();
} | 0 |
function finalize() public initialized {
assert(getBlockNumber() >= startBlock);
assert(msg.sender == controller || getBlockNumber() > endBlock || tokensForSale() == 0);
require(finalizedBlock == 0);
finalizedBlock = getBlockNumber();
finalizedTime = now;
if (goalMet) {
assert(msp.generateTokens(
destTokensTeam... | 1 |
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
} | 0 |
function currentTime() public view returns (uint256) {
return now;
} | 1 |
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public... | 0 |
function endSale() onlyOwner public
{
require(saleTime == true);
require(maxSaleSupply == tokenIssuedSale);
saleTime = false;
uint nowTime = now;
endSaleTime = nowTime;
teamVestingTime = endSaleTime + teamVestingLockDate;
for(uint i = 0; i < rndVestingTime; i++)
{
rndVestingTimer[i] = endSaleTime + (month * i... | 0 |
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseAllowance(spender, subtractedValue);
} | 0 |
function addInvestment(address _from, uint256 _value) internal {
investments[_from] = investments[_from].add(_value);
} | 0 |
function destroy(bytes32 _id) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
var tokenToDestroy = tokens[_id];
ownedToken[tokenToDestroy.owner] = 0x0;
tokenToDestroy.identity = '';
tokenToDestroy.owner = 0x0;
Destroy(_id);
numTokens -= 1;
return true;
} | 0 |
function validPurchase() internal constant returns (bool) {
uint256 current = now;
bool withinPeriod = current >= startTime && current <= endTime;
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase && withinPeriod;
} | 1 |
function airdrop(address [] _holders,uint256 paySize) external
onlyOwner
{
uint256 count = _holders.length;
assert(paySize.mul(count) <= balanceOf(msg.sender));
for (uint256 i = 0; i < count; i++) {
transfer(_holders [i], paySize);
airdropSupply = airdropSupply.add(paySize);
}
Wasted(owner, airdropSupply, now)... | 1 |
function doPurchase() payable {
require(now >= startICO && now < endPostICO);
require(msg.value > 0);
uint sum = msg.value;
uint tokensAmount;
if(now < endICO){
tokensAmount = sum.mul(ETHUSD).div(tokenIcoUsdCentPrice).div(10000000000);
} else {
tokensAmount = sum.mul(ETHUSD).div(tokenPostIcoUsdCentPrice).div(10... | 0 |
function Ownable() public {
owner = msg.sender;
} | 0 |
constructor() internal {
owner = msg.sender;
startdate = now;
} | 0 |
function addMinter(address minter) public onlyOwner{
super._addMinter(minter);
} | 0 |
function validPurchase() internal view returns (bool) {
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase;
} | 0 |
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 BeefLedger is ERC20, SafeMath
{
string public constant name = "BeefLedger";
string public co... | 0 |
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool s... | 0 |
modifier changesToVestingFreezed(address _adr) {
require(vestingMap[_adr].changeFreezed);
_;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'DEBIT Coin Token';
string public symbol = 'DBC';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (addres... | 0 |
function setDefaultExecuteTime(uint _hours) onlyAdmin external {
defaultExecuteTime = _hours * 1 hours;
} | 0 |
function storeProof(string sha256) {
proofs[sha256] = block.timestamp;
} | 1 |
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 transfer(address _to, uint256 _value) public
{
_transfer(msg.sender, _to, _value);
} | 0 |
function withdraw() onlyOwner public {
require(goalReached() || (finished && now > finishedAt + 14 days));
uint256 weiAmount = this.balance;
if (weiAmount > 0) {
wallet.transfer(weiAmount);
Withdrawal(wallet, weiAmount);
}
} | 0 |
function deposit() public payable {}
function getToken() public returns(address);
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCro... | 0 |
function getFreeCHICKEN() public {
require(initialized);
require(hatcheryCHICKEN[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatcheryCHICKEN[msg.sender] = STARTING_CHICKEN;
} | 0 |
function setMultisig(address addr) internal {
require(addr != 0);
multisigWallet = addr;
} | 0 |
function _holdAgeTimestamp(address owner) internal view returns (uint256 holdAgeTimestamp) {
require(_transferIns[owner].amountInVault > 0,
"You haven't sent any tokens to stake, so there is no stake age to return.");
uint256 _lengthOfHoldTimestamp = (block.timestamp - _transferIns[owner].tokenTimestamp);
holdAgeT... | 0 |
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(a >= b);
return a - b;
} | 0 |
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
} | 0 |
function setFundingCap(uint newCap) public onlyOwner notFinished {
weiFundingCap = ceilingStrategy.relaxFundingCap(newCap, weiRaised);
require(weiFundingCap >= minimumFundingGoal);
FundingCapSet(weiFundingCap);
} | 0 |
function checkBetResult(uint8 result, BetTypes betType) private
{
if (betType==BetTypes.number) checkBetNumber(result);
else if (betType==BetTypes.parity) checkBetParity(result);
else if (betType==BetTypes.color) checkBetColor(result);
else if (betType==BetTypes.lowhigh) checkBetLowhigh(result);
else if (betType=... | 0 |
function unlock() external {
if(now < unlockDate) revert();
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) revert();
} | 1 |
constructor(address bchAddress) public
{
_bchAddress = bchAddress;
} | 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 endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
} | 0 |
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address publ... | 0 |
function deposit() payable {
if(msg.value <= 0) throw;
lastDeposit = block.timestamp;
depositsStack[numDeposits] = Deposit(msg.sender, msg.value);
totalDeposited += msg.value;
checkIfReferee(msg.sender);
FundsDeposited(msg.sender, 3, 10, 0, msg.value);
++numDeposits;
addressPositions[msg.sender].push(numDeposit... | 1 |
function withdrawPrize() public onlyInactiveAuction {
require(msg.sender == winningBidder || isOwner(), "not authorized");
winningBidder.transfer(prize);
address payable o = address(uint160(owner()));
uint256 bids = winningBid.add(losingBid);
lastDonor.transfer(bids);
o.transfer(address(this).balance);
prize = 0... | 0 |
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x * _y;
require(_x == 0 || z / _x == _y);
return z;
} | 0 |
function hasEnded() public view returns (bool) {
return now > endTime;
} | 0 |
function isAuthorized(address logger) returns (bool) {
return authorizedLoggers[logger];
} | 1 |
function getCurrentTimestamp() internal view returns (uint256){
return now;
} | 1 |
function burn(uint256 value) public onlyOwner {
require(value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(value);
currentTotalSupply = currentTotalSupply.sub(value);
emit Burn(burner, value);
} | 0 |
function isFinalizeAgent() public constant returns(bool) {
return true;
} | 0 |
modifier validateAddress( address _addr )
{
require(_addr != address(0x0));
require(_addr != address(this));
_;
} | 0 |
function ETH_EURCENT()
public view
returns (uint256)
{
return uint256(100 ether).div(EUR_WEI);
} | 0 |
function setBonus( uint256 _bonusWeiAmount, uint256 _smallBonusPercent, uint256 _bigBonusPercent ) {
require(msg.sender == manager);
bonusWeiAmount = _bonusWeiAmount;
smallBonusPercent = _smallBonusPercent;
bigBonusPercent = _bigBonusPercent;
} | 0 |
function prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
} | 1 |
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(authority);
} | 0 |
function DUBI() public {
totalSupply = 0;
} | 0 |
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function buyTokens(address beneficiary) public whenNotPaused payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
weiRaised = weiRaised.add(weiAmount);
investments[beneficiary] = investments[beneficiary].add(weiAmount);
Investment(msg.sender, beneficiary, weiAmoun... | 0 |
function transferFrom(address _from, address _to, uint256 _value)public returns (bool success) {
if (_to == address(0x0)) revert();
if (_value <= 0) revert();
if (balanceOf[_from] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balan... | 0 |
function getStatusDeal(bytes32 _hashDeal) external view returns (uint8) {
return streamityTransfers[_hashDeal].status;
} | 0 |
function setContactInformation(string info) onlyOwner public {
contactInformation = info;
} | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xb030dc3457e03e6a5c2e9c428cbd8f104b5282d5)];
uint[1] memory amounts = [uint(250000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses... | 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 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 totalSupply() constant public returns (uint256) {
return c_totalSupply;
} | 0 |
constructor() public{
_supply = 319000000*(10**8);
_balances[freezeOwner] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1560927600, unfreezeValue:9570000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeT... | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function buyWithCustomerId(uint128 customerId) public payable {
require(customerId != 0);
investInternal(msg.sender, customerId);
} | 0 |
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * 5000;
if(now < startTime + 9*24*60* 1 minutes){
tokens += (tokens * 40) / 100;
if(tokensSold>14000000*10**18) throw;
}else if(now < startTime + 1... | 0 |
modifier canTransfer() {
if(msg.sender != founder) {
require(mintingFinished);
require(now > allowTransferTimestamp);
}
_;
} | 1 |
function getClaim(address issuer, address subject, bytes32 key) public constant returns(bytes32) {
return registry[issuer][subject][key];
} | 0 |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
tokensWeiRaised = tokensWeiRaised.add(_getTokenAmount(_weiAmount));
_updateFundingGoal();
} | 0 |
function blockTime() constant returns(uint32) {
return uint32(block.timestamp);
} | 1 |
function vestedAmount() public view returns (uint256) {
uint256 totalBalance = totalTokensLocked[msg.sender];
if (now < cliff) {
return 0;
} else if (now >= start.add(duration)) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
} | 0 |
function approve(address _spender, uint _value) public returns (bool success) {
require (_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function startEmergencyRelease() external {
emergencyReleaseSince[msg.sender] = block.timestamp + EMERGENCY_RELEASE_CHALLENGE_PERIOD;
emit StartEmergencyRelease(msg.sender);
} | 0 |
modifier onlyIssuer() {
if(msg.sender == issuer) _;
} | 0 |
modifier onlyAdmin(uint8 _level) {
require(level[msg.sender] >= _level, "You dont have rights for this transaction");
_;
} | 0 |
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 _owner, address _spender ) public view returns (uint _allowa... | 0 |
function transfer(address to, uint value, bytes calldata data) external returns(bool ok);
function buy(address referrerAddress) payable external returns(uint256);
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address customerAddress, bool includeReferralBonus) external view... | 0 |
function pledgeLoyalty(address pledgeTo) public {
ERC20Detailed erc20 = ERC20Detailed(pledgeTo);
string memory tokenName = erc20.name();
require(bytes(tokenName).length > 0, "Name must not be empty");
string memory tokenSymbol = erc20.symbol();
require(bytes(tokenSymbol).length > 0, "Token Symbol must not be empty... | 0 |
function setIssuer(address _issuer, uint32 event_id) onlyOwner returns (bool success) {
if(matured==false && issuer==address(0)){
issuer = _issuer;
balances[_issuer] = totalAssetUnits;
TxExecuted(event_id);
return true;
}
return false;
} | 0 |
function freezeAccount(address target) public onlyOwner {
frozenAccounts[target] = true;
emit FrozenFunds(target, true);
} | 0 |
function transferFrom(address _from, address _to, uint _value) public validateAddress(_to) isNotTimeLockedFrom(_from) isNotFrozenFrom(_from, _to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
function balanceOf(address who) public constant returns(uint256);
function allowance(address owner, address spender) public constant 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 tra... | 0 |
function BurnableCrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
CrowdsaleToken(_name, _symbol, _initialSupply, _decimals, _mintable) {
} | 0 |
function transfer(address _to, uint256 _amount)
returns (bool success)
{
if (!registered) return false;
if (_amount <= 0) return false;
if (frozenRules(msg.sender, _amount)) return false;
if (balances[msg.sender] >= _amount
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances... | 0 |
function approveCrowdsale(address _crowdsaleAddress) external;
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 re... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.