function string | label int64 |
|---|---|
function WePoolCrowdsale(uint256 _preIcoStartTime, uint256 _icoStartTime) public {
require(_preIcoStartTime > now);
require(_icoStartTime > _preIcoStartTime + 7 days);
preIcoStartTime = _preIcoStartTime;
icoStartTime = _icoStartTime;
minPurchase = 0.1 ether;
preIcoRate = 0.00008 ether;
icoRate = 0.0001 ether;
h... | 0 |
function forceClose(uint _agreementNumber) {
assert(agreements[_agreementNumber].tokenAmount > 0);
bool marginCall = !isCollateralWithinMargin(
agreements[_agreementNumber].tokenAmount,
agreements[_agreementNumber].collateralAmount,
agreements[_agreementNumber].collateralRatio);
if (marginCall || now > agreements... | 1 |
modifier notFinished() {
State current_state = getState();
require(current_state == State.PreFunding || current_state == State.Funding);
_;
} | 0 |
function getTime() public returns (uint256) {
return now;
} | 1 |
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 (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function unreserveFor(address investor) managerOnly {
require(reservedInvestors[investor] != 0);
knownReserved--;
unreserveTokens(reservedInvestors[investor]);
reservedInvestors[investor] = 0;
ReserveKnown(false, investor, 0, 0);
} | 0 |
function assignRole(address _from, bytes32 _role, address _to) returns(bool) {
return assignRoleWithExpiration(_from, _role, _to, LIFETIME);
} | 0 |
function countWhitelists() view public returns (uint) {
return WhitelistsAccts.length;
} | 0 |
function approve(address _spender, uint256 _value) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
} | 0 |
function isTransferable(address _who) private view returns (bool)
{
if(blackLists[_who] == true)
{
return false;
}
if(tokenLock == false)
{
return true;
}
else if(msg.sender == owner1 || msg.sender == owner2)
{
return true;
}
return false;
} | 0 |
function releaseTokenTransfer() public onlyReleaseAgent {
Released();
released = true;
} | 0 |
function transferFrom(address _from, address _to, uint _value) public canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
} | 0 |
constructor(address wibxTokenAddress) public
{
_wibxToken = WibxToken(wibxTokenAddress);
} | 0 |
function withdraw()
public
{
require(donationData[msg.sender] > 0);
require(block.timestamp > (timeStarted + expirationInSeconds));
require(hasBeenClaimed == false);
var value = donationData[msg.sender];
donationData[msg.sender] = 0;
msg.sender.transfer(value);
} | 0 |
function distributeCrowdsaleTokens(address _buyer, uint tokens) external onlyCrowdsale whenNotPaused {
require(_buyer != address(0));
require(tokens > 0);
require(tokensDistributedCrowdsale < limitCrowdsale);
require(tokensDistributedCrowdsale.add(tokens) <= limitCrowdsale);
tokensDistributedCrowdsale = tokensDist... | 0 |
function updatePromoter4(address _address) external onlyOwner {
require(_address != address(0x0));
promoter4 = _address;
} | 0 |
modifier transferable(address _addr) {
require(!lockAddresses[_addr]);
_;
} | 0 |
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 tokenID) public;
function totalSupply() public view returns (uint);
functi... | 0 |
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
function allowance(address _owner, address _spender) exter... | 0 |
function cancelTrident() external returns (bool) {
uint256 _amountInVault = _transferIns[msg.sender].amountInVault;
require(_amountInVault > 0, "You have not staked any tokens.");
_transferIns[msg.sender].amountInVault = 0;
_transferIns[msg.sender].tokenTimestamp = block.timestamp;
_remoteTransferFrom(address(this... | 0 |
function transferToken(address _from, address _to, uint256 _tokenId) internal {
require(tokenExists(_tokenId));
require(memeData[_tokenId].owner == _from);
require(_to != address(0));
require(_to != address(this));
clearApproval(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
emit Trans... | 0 |
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) constan... | 0 |
modifier onTime() {
require(block.number >= startPreico && now <= endPreico);
_;
} | 0 |
modifier ICOTerminated() {
require(now > termination * 1 seconds);
_;
} | 1 |
function setUpgradeAgent(address agent) onlyMaster external {
require(canUpgrade());
require(agent != 0x0);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSupply());
UpgradeAgentSet(up... | 0 |
function changePreIcoStartTime(uint256 newTime) public onlyOwner {
require(now < preIcoStartTime);
require(newTime > now);
require(icoStartTime > newTime + 7 days);
preIcoStartTime = newTime;
} | 0 |
function balanceOf(address _owner) public constant 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 totalSupply()
constant
returns (uint256)
{
return totalTokens;
} | 0 |
function getCurrentRate() public view returns (uint256) {
return rate.add(bonusRate);
} | 0 |
function approve(address spender, uint256 value)public returns (bool ok);
function transfer(address to, uint256 value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract UpgradeAge... | 0 |
function min64(uint64 a, uint64 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
} | 0 |
function upgradeFrom(address holder, uint256 value) fromPrevContract public returns (bool) {
balances[holder] = value;
Transfer(address(0), holder, value);
UpgradeFrom(address(prevContract), holder, value);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
allowed[_from][msg.sender] = safeSub(_allowance, _value);
safeTransfer(_from, _to, _value);
return true;
} | 0 |
function refund() external {
require (isFinalized == false);
require (isActive == true);
require (now > fundingEndTime);
require(_raised < tokenCreationMin);
require(msg.sender != owner);
uint256 ethValRefund = refunds[msg.sender];
require(ethValRefund > 0);
refunds[msg.sender] = 0;
uint256 allstocksVal = ERC2... | 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 vestToTeam (address who, uint256 amount) public onlyOwner {
require(who != address(0));
_tokensForTeamAndAdvisors = _tokensForTeamAndAdvisors.sub(amount);
team[who] = team[who].add(amount);
emit VestedToTeam(who, amount);
} | 0 |
function changeLimit(uint _bottom, uint _top) public onlyOwner {
LimitBottom = _bottom;
LimitTop = _top;
} | 0 |
function totalSupply() public view returns (uint) {
return total_supply;
} | 0 |
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
constructor(uint256 _fee) public {
commissionFee = _fee;
owner = msg.sender;
} | 0 |
function transferICO(address _to, uint256 _value) public onlyOwner returns (bool) {
require(isICO, "Not ICO phase");
require(_to != address(0), "Zero address 'To'");
require(_value <= balances[wallet], "Not enought balance");
balances[wallet] = balances[wallet].sub(_value);
balances[_to] = balances[_to].add(_value... | 0 |
function identityOf(bytes32 _id) constant returns (string identity) {
return tokens[_id].identity;
} | 0 |
function getCurrentInvestments() view external onlyOwner returns(uint256)
{
return address(this).balance;
} | 0 |
function buyTokens() public payable;
function forwardFunds() internal {
teamWallet.transfer(msg.value);
} | 0 |
function addComment(string _comment, address _to, bool _aboutBounty, uint _bountyId)
public
{
if (_aboutBounty){
comments.push(Comment(_comment, msg.sender, address(0), _aboutBounty, _bountyId, block.timestamp));
} else {
comments.push(Comment(_comment, msg.sender, _to, _aboutBounty, _bountyId, block.timestamp));... | 0 |
function withdraw() public onlyOwner {
require(depositedTime > 0, "not deposited");
uint256 currentPeriod = now.sub(depositedTime).div(periodLength);
require(currentPeriod > 0, "invalid period 1");
require(withdrawalByPeriod[currentPeriod] == 0, "already withdrawn");
uint256 balance = token.balanceOf(address(this)... | 0 |
function enteranews(string memory uHeadline, string memory uMessage) public payable {
require(msg.value >= .001 ether,"This contrat works with minimum 0.001 ether");
require(journal[msg.sender].time == 0,"An account can only be used once.");
manager.transfer(msg.value);
journal[msg.sender].time = now;
journal[msg.... | 0 |
function getGameSettings() external view returns (
uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparat... | 0 |
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
require (!isFinalized);
uint256 tokens = safeMult(_value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(totalSupply, tokens);
if (tokenCreationCap... | 1 |
constructor() internal {
owner = msg.sender;
startdate = now;
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function mintLockedToken(address addr, uint256 tokens, uint256 _duration) public;
function releaseLockedToken() public returns (bool);
function isLocked(address addr) public view returns (bool) {
return _lock_list[addr];
} | 0 |
function initProlongationVoting() public onlyOwner {
require(!prolongationVoted);
init(now, 24 hours, 30);
prolongationVoted = true;
} | 0 |
modifier onlyCrowdsale() {
require(msg.sender == crowdsaleAddress);
_;
} | 0 |
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) ... | 0 |
function indexOf(address[] values, address value) internal pure returns (int) {
uint i = 0;
while (i < values.length) {
if (values[i] == value) {
return int(i);
}
i++;
}
return int(- 1);
} | 0 |
function updatePriceDenominator(uint256 newDenominator) external onlyFundWallet {
require(block.number > fundingEndBlock);
require(newDenominator > 0);
currentPrice.denominator = newDenominator;
prices[previousUpdateTime] = currentPrice;
previousUpdateTime = now;
PriceUpdate(currentPrice.numerator, newDenominator... | 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 pur... | 0 |
function authorized_updateCardReserved1(uint256 _cardId, uint8 _reserved) external requireAuthorizedLogicContract {
uint8 _reserved8 = uint8(_reserved);
require(_reserved == uint256(_reserved8));
Card storage card = allCards[_cardId];
card.reserved1 = _reserved8;
} | 0 |
function ParetoFourMonthLockup()public {
token = ERC20Basic(0xea5f88E54d982Cbb0c441cde4E79bC305e5b43Bc);
beneficiary = 0x439f2cEe51F19BA158f1126eC3635587F7637718;
releaseTime = now + 120 days;
} | 0 |
function validPurchase() internal view returns (bool) {
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase;
} | 0 |
function proposeWithFeeRecipient(address feeRecipient, address target, bytes memory data) public returns (uint) {
require(msg.sender != address(this) && target != address(token), "Governance::proposeWithFeeRecipient: Invalid proposal");
require(token.transferFrom(msg.sender, address(this), proposalFee), "Governance::... | 0 |
function myStakeMinimumTimestamp() external view returns (uint) {
return _transferIns[msg.sender].stakeMinimumTimestamp;
} | 0 |
function checkBetParity(uint8 result) private
{
bool win;
if (result%2==gambles[gambleIndex[msg.sender]].input && result!=0)
{
win=true;
}
solveBet(msg.sender,result,win,2);
} | 0 |
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
Unpause();
return true;
} | 0 |
function destroy(address _from, uint256 _amount) public;
}
contract DebitCoinToken is IDebitCoinToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true;
uint public MiningRewardPerETHBlock = 5;
uint public lastBlockRewarded;
event DebitCoinTokenGenesis(address _to... | 0 |
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address ind... | 0 |
function _pause() internal whenNotPaused {
_paused = true;
emit Paused(msg.sender);
} | 0 |
function totalAlocatedWibxVestingTokens() public view returns (uint256)
{
return _alocatedWibxVestingTokens;
} | 0 |
function max256(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
} | 0 |
function depositDividends() payable external onlyOwner
{
address(this).transfer(msg.value);
} | 0 |
function paused() public view returns (bool) {
return _paused;
} | 0 |
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _ow... | 0 |
function min256(uint a, uint b) internal constant returns (uint) {
return a < b ? a : b;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to... | 0 |
function hasEnded() public constant returns(bool) {
return now > endTime || tokensRaised >= maxTokensRaised;
} | 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 changeWaitTime(uint256 newWaitTime) external onlyFundWallet {
waitTime = newWaitTime;
} | 0 |
function getOrderHash(Order order) private returns(bytes32) {
return keccak256(
this,
order.orderType,
order.maker,
order.baseToken,
order.quoteToken,
order.feeToken,
order.amount,
order.priceNumerator,
order.priceDenominator,
order.feeNumerator,
order.feeDenominator,
order.expiresAt,
order.nonce
);
} | 0 |
function totalSupply() constant returns (uint256);
function balanceOf(address who) constant returns (uint256);
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 sp... | 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);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
... | 0 |
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint8 public decimals;
}
contract BasicToken ... | 0 |
function setVendorWallet(address newVendorWallet) onlyOwner public returns (bool) {
require(newVendorWallet != 0x0);
vendorWallet = newVendorWallet;
return true;
} | 0 |
function balanceOf(address who) public constant returns (uint256);
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);
... | 0 |
function transfer(address to, uint256 value) public returns (bool) {
require(!paused(), "Pausable: token transfer is paused.");
super._transfer(msg.sender, to, value);
return true;
} | 0 |
function setBlockingState(address _addr, uint256 _end, uint256 _value) isBlockingTransfer public {
require(
msg.sender == owner ||
msg.sender == co_owner
);
require(_addr != address(0));
uint256 final_value = _value;
if(release_dates[_addr] != 0x0){
final_value = blocked_amounts[_addr].add(_value);
}
release_... | 0 |
function getIssuer() constant returns (address _issuer) {
return issuer;
} | 0 |
modifier when_beneficiary_is_unknown() {
require(beneficiary == address(0));
_;
} | 0 |
function getState() public constant returns (State) {
if (finalized) return State.Finalized;
else if (block.number < startsAt) return State.PreFunding;
else if (block.number <= endsAt && !ceilingStrategy.isCrowdsaleFull(weiRaised, weiFundingCap)) return State.Funding;
else if (isMinimumGoalReached()) return State.S... | 0 |
function initiateMigration(address sender, Proxy identity, address newIdManager) public
onlyAuthorized
onlyOlderOwner(identity, sender)
{
migrationInitiated[identity] = now;
migrationNewAddress[identity] = newIdManager;
LogMigrationInitiated(identity, newIdManager, sender);
} | 0 |
function getEggsSinceLastHatch(address _address) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1CRAB, SafeMath.sub(now, lastHatch[_address]));
return SafeMath.mul(secondsPassed, hatchery[_address]);
} | 0 |
function setupAmbi2(Ambi2 _ambi2) returns(bool) {
if (address(ambi2) != 0x0) {
return false;
}
if (!_ambi2.claimFor(this, msg.sender) && !_ambi2.isOwner(this, msg.sender)) {
return false;
}
ambi2 = _ambi2;
return true;
} | 0 |
function Bettium()public{
totalSupply = 1000000000*10**decimals;
balances[walletICO] = totalSupply;
transferFrom(this,walletICO, 0);
} | 0 |
function ExpiringMarket(uint lifetime) {
close_time = getTime() + lifetime;
} | 0 |
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) public returns (bool _success);
}
contract ITAMToken is ERC20Interface, OwnerH... | 0 |
constructor( address _registry, uint _totalTokenAmount ) public
{
_mint(_registry, _totalTokenAmount);
addSuperAdmin(_registry);
} | 0 |
modifier _contractUp(){
require(contractUp);
_;
} | 0 |
function setTrust(address addr) setter onlyOwnerUnlocked {
trustAddress = addr;
} | 0 |
function dividendsOf(address customerAddress, bool includeReferralBonus) external view returns(uint256);
function withdraw() external;
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
... | 0 |
function isLocked(address _spender) public view returns (bool) {
if (releaseTimes[_spender] == 0 || releaseTimes[_spender] <= block.timestamp) {
return false;
}
return true;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.