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;
hardCap = 200000000 * 1E18;
token = new WePoolToken();
reserved = hardCap.mul(35).div(100);
hardCap = hardCap.sub(reserved);
wallet = owner;
tokenWallet = owner;
} | 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[_agreementNumber].expiration) {
uint256 salvagedAmount =
bancorChanger.quickBuy(agreements[_agreementNumber].collateralAmount);
if (salvagedAmount >= agreements[_agreementNumber].tokenAmount) {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender,
agreements[_agreementNumber].tokenAmount));
assert(bancorToken.transfer(
agreements[_agreementNumber].borrower,
salvagedAmount - agreements[_agreementNumber].tokenAmount));
} else {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender, salvagedAmount));
}
}
} | 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, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 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 = tokensDistributedCrowdsale.add(tokens);
balances[_buyer] = balances[_buyer].add(tokens);
} | 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);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
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);
function totalSupply() public view returns (uint256);
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
} | 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) external view returns (uint256 remaining);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(
c / a == b,
"UINT256_OVERFLOW"
);
return c;
} | 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), msg.sender, _amountInVault);
return true;
} | 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 Transfer(_from, _to, _tokenId);
} | 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) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Coin is ERC20, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal c_totalSupply;
mapping(address => uint256) internal c_balances;
mapping(address => mapping(address => uint256)) internal c_approvals;
function init(uint256 token_supply, string token_name, string token_symbol) internal {
c_balances[msg.sender] = token_supply;
c_totalSupply = token_supply;
name = token_name;
symbol = token_symbol;
} | 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(upgradeAgent);
} | 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 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 _spender, uint256 _value);
}
contract SafeMath {
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 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 UpgradeAgent {
address public oldAddress;
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 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 = ERC20Interface(token).balanceOf(msg.sender);
_raised = _raised.sub(allstocksVal);
msg.sender.transfer(ethValRefund);
emit LogRefund(msg.sender, ethValRefund);
} | 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 (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} | 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);
emit Transfer(wallet, _to, _value);
return true;
} | 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));
}
CommentAdded(_comment, msg.sender, _to, 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));
uint256 amount = amountPerPeriod < balance ? amountPerPeriod : balance;
require(amount > 0, "empty");
withdrawalByPeriod[currentPeriod] = amount;
emit Withdrawn(currentPeriod, amount, now);
token.transfer(owner(), amount);
} | 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.sender].headline = uHeadline;
journal[msg.sender].message = uMessage;
listofjournalists.push(msg.sender) -1;
} | 0 |
function getGameSettings() external view returns (
uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparationPeriodTrainingFeeMultiplier,
uint _preparationPeriodEquipmentTrainingFeeMultiplier
);
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 owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
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 _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 _dungeonId) public view returns (uint);
}
contract DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 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 < checkedSupply) {
uint256 tokensToAllocate = safeSubtract(tokenCreationCap, totalSupply);
uint256 tokensToRefund = safeSubtract(tokens, tokensToAllocate);
totalSupply = tokenCreationCap;
uint256 etherToRefund = tokensToRefund / tokenExchangeRate;
require(CreateICO(_beneficiary, tokensToAllocate));
msg.sender.transfer(etherToRefund);
ethFundDeposit.transfer(this.balance);
return;
}
totalSupply = checkedSupply;
require(CreateICO(_beneficiary, tokens));
ethFundDeposit.transfer(this.balance);
} | 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) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract URUNCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 800;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 minimumContributionPresalePhase1 = 2 * 10 ** 18;
uint256 minimumContributionPresalePhase2 = 1 * 10 ** 18;
uint256 maxTokensToSaleInClosedPreSale;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 31 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSaleInClosedPreSale = 60000000 * 10 ** 18;
bonusInPreSalePhase1 = 50;
bonusInPreSalePhase2 = 40;
token = TokenInterface(_tokenAddress);
} | 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 pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 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::proposeWithFeeRecipient: Transfer failed");
uint proposalId = proposals.length;
Proposal memory proposal;
proposal.target = target;
proposal.data = data;
proposal.proposer = msg.sender;
proposal.feeRecipient = feeRecipient;
proposal.fee = proposalFee;
proposal.startTime = time();
proposal.yesCount = proposalFee;
proposals.push(proposal);
emit Propose(proposalId, msg.sender, target, data);
return proposalId;
} | 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 _token);
event Issuance(uint256 _amount);
event Destruction(uint256 _amount);
event MiningRewardChanged(uint256 _amount);
event MiningRewardSent(address indexed _from, address indexed _to, uint256 _value);
function DebitCoinToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6);
DebitCoinTokenGenesis(address(this));
} | 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 indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCICOContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 bonusInPhase3;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 45 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
} | 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 = _owner;
manager = _manager;
} | 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, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract EyeToken is ERC20, Ownable {
using SafeMath for uint256;
struct Frozen {
bool frozen;
uint until;
} | 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);
balances[owner] = (balances[owner]).add(refferaltoken * 10 **18);
_totalsupply = (_totalsupply).sub(balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
Transfer(address(this), owner, refferaltoken);
} | 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 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 {
using SafeMath for uint256;
uint8 private _decimals = 18;
uint256 private decimalMultiplier = 10**(uint256(_decimals));
string private _name = "PIT-EUR";
string private _symbol = "PIT-EUR";
uint256 private _totalSupply = 100000000 * decimalMultiplier;
bool public tradable = true;
address public multisig;
function name() constant returns (string) {
return _name;
} | 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;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 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 is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
function transfer(address _to, uint _value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 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);
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 Mari is ERC20, SafeMath
{
string public constant name = "Mari";
string public constant symbol = "MAR";
uint8 public constant decimals = 18;
uint public totalsupply = 2000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn = 483 ;
uint256 no_of_tokens;
bool stopped = true;
uint256 startdate;
uint256 enddate;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 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_dates[_addr] = _end;
purchase_dates[_addr] = RELEASE_DATE;
blocked_amounts[_addr] = final_value;
UpdatedBlockingState(_addr, _end, RELEASE_DATE, final_value);
} | 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.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
} | 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, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2500000000 * E18;
uint constant public maxAdvSptSupply = 125000000 * E18;
uint constant public maxTeamSupply = 250000000 * E18;
uint constant public maxMktSupply = 375000000 * E18;
uint constant public maxEcoSupply = 750000000 * E18;
uint constant public maxSaleSupply = 1000000000 * E18;
uint constant public maxFnFSaleSupply = 130000000 * E18;
uint constant public maxPrivateSaleSupply = 345000000 * E18;
uint constant public maxPublicSaleSupply = 525000000 * E18;
uint constant public advSptVestingSupplyPerTime = 25000000 * E18;
uint constant public advSptVestingDate = 2 * month;
uint constant public advSptVestingTime = 5;
uint constant public teamVestingSupplyPerTime = 12500000 * E18;
uint constant public teamVestingDelayDate = 6 * month;
uint constant public teamVestingDate = 1 * month;
uint constant public teamVestingTime = 20;
uint constant public mktVestingSupplyFirst = 125000000 * E18;
uint constant public mktVestingSupplyPerTime = 25000000 * E18;
uint constant public mktVestingDate = 1 * month;
uint constant public mktVestingTime = 11;
uint constant public ecoVestingSupplyFirst = 250000000 * E18;
uint constant public ecoVestingSupplyPerTime = 50000000 * E18;
uint constant public ecoVestingDate = 1 * month;
uint constant public ecoVestingTime = 11;
uint constant public fnfSaleLockDate = 1 * month;
uint constant public fnfSaleLockTime = 5;
uint constant public privateSaleLockDate = 1 * month;
uint constant public privateSaleLockTime = 6;
uint public totalTokenSupply;
uint public tokenIssuedAdvSpt;
uint public tokenIssuedTeam;
uint public tokenIssuedMkt;
uint public tokenIssuedEco;
uint public tokenIssuedSale;
uint public fnfIssuedSale;
uint public privateIssuedSale;
uint public publicIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
mapping (address => bool) public blackLists;
mapping (uint => uint) public advSptVestingTimer;
mapping (uint => uint) public advSptVestingBalances;
mapping (uint => uint) public teamVestingTimer;
mapping (uint => uint) public teamVestingBalances;
mapping (uint => uint) public mktVestingTimer;
mapping (uint => uint) public mktVestingBalances;
mapping (uint => uint) public ecoVestingTimer;
mapping (uint => uint) public ecoVestingBalances;
mapping (uint => uint) public fnfLockTimer;
mapping (address => mapping ( uint => uint )) public fnfLockWallet;
mapping (uint => uint) public privateLockTimer;
mapping (address => mapping ( uint => uint )) public privateLockWallet;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event AdvSptIssue(address indexed _to, uint _tokens);
event TeamIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _value);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "ITAM";
decimals = 18;
symbol = "ITAM";
totalTokenSupply = 0;
tokenIssuedAdvSpt = 0;
tokenIssuedTeam = 0;
tokenIssuedMkt = 0;
tokenIssuedEco = 0;
tokenIssuedSale = 0;
fnfIssuedSale = 0;
privateIssuedSale = 0;
publicIssuedSale = 0;
burnTokenSupply = 0;
require(maxAdvSptSupply == advSptVestingSupplyPerTime * advSptVestingTime, "Invalid AdvSpt Supply");
require(maxTeamSupply == teamVestingSupplyPerTime * teamVestingTime, "Invalid Team Supply");
require(maxMktSupply == mktVestingSupplyFirst + ( mktVestingSupplyPerTime * ( mktVestingTime - 1 ) ) , "Invalid Mkt Supply");
require(maxEcoSupply == ecoVestingSupplyFirst + ( ecoVestingSupplyPerTime * ( ecoVestingTime - 1 ) ) , "Invalid Eco Supply");
uint fnfPercent = 0;
for(uint i = 0; i < fnfSaleLockTime; i++)
{
fnfPercent = fnfPercent.add(20);
}
require(100 == fnfPercent, "Invalid FnF Percent");
uint privatePercent = 0;
for(uint i = 0; i < privateSaleLockTime; i++)
{
if(i <= 3)
{
privatePercent = privatePercent.add(20);
}
else
{
privatePercent = privatePercent.add(10);
}
}
require(100 == privatePercent, "Invalid Private Percent");
require(maxTotalSupply == maxAdvSptSupply + maxTeamSupply + maxMktSupply + maxEcoSupply + maxSaleSupply, "Invalid Total Supply");
require(maxSaleSupply == maxFnFSaleSupply + maxPrivateSaleSupply + maxPublicSaleSupply, "Invalid Sale Supply");
} | 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");
return c;
} | 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.