function
string | label
int64 |
|---|---|
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
} | 0 |
function getNow() internal constant returns (uint256) {
return now;
} | 1 |
function tokenFallback(address _from, uint256 _value, bytes _data) external {
throw;
} | 0 |
function createPost(string _link) public returns(uint256) {
Post memory post = Post({
link: _link,
poster: msg.sender,
voteCount: 0,
datePosted: uint64(now)
});
posts[postId] = post;
linkToPostId[_link] = postId;
postExists[postId] = true;
uint256 currentPostId = postId;
incrementpostId();
return currentPostId;
} | 1 |
function checkCompletedCrowdsale() public whenNotPaused {
if(!isEnded) {
if(hasEnded() && !goalReached()){
vault.enableRefunds();
isRefunding = true;
isEnded = true;
Finalized();
} else if(hasEnded() && goalReached()) {
vault.close();
isEnded = true;
Finalized();
}
}
} | 0 |
function increaseApproval (address _spender, uint256 _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function getMaxParticipants() public constant returns(uint256 _max){
return currentPeople;
} | 0 |
function setBalanceOf(address _investor, uint256 _newValue) internal
{
require(_investor!=0x0000000000000000000000000000000000000000);
balances[_investor]=_newValue;
} | 0 |
function balanceOf(address _owner) external view returns (uint256 balance);
}
contract Timelock {
ERC20Token public token;
address public beneficiary;
uint256 public releaseTime;
event TokenReleased(address beneficiary, uint256 amount);
constructor(
address _token,
address _beneficiary,
uint256 _releaseTime
) public {
require(_releaseTime > now);
require(_beneficiary != 0x0);
token = ERC20Token(_token);
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 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 _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken 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 = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LNX Protocol";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
} | 0 |
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable, Pausable, Destructible {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
} | 0 |
function getStartPreIco() public view returns (uint256) {
uint256 nowTime = block.timestamp;
uint256 _preIcoStartTime = nowTime + 1 minutes;
return _preIcoStartTime;
} | 0 |
function disallowTransfers() onlyOwner {
transfersAllowed = false;
} | 0 |
function release(IERC20 token) public {
uint256 unreleased = _releasableAmount(token);
require(unreleased > 0);
_released[address(token)] = _released[address(token)].add(unreleased);
token.transfer(_beneficiary, unreleased);
emit TokensReleased(address(token), unreleased);
} | 0 |
function _transfer(address _to, uint256 _value) private returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
} | 0 |
function QuickFlip() public {
owner = msg.sender;
cardOwner = msg.sender;
cardPrice = STARTING_PRICE;
} | 0 |
function authorize(address wlCandidate) public backEnd {
require(wlCandidate != address(0x0));
require(!isWhitelisted(wlCandidate));
whitelist[wlCandidate] = true;
emit Authorized(wlCandidate, now);
} | 0 |
function updateRate(uint256 _weiPerUnitRate) external;
function getRate() external view returns(uint256);
function getLastTimeUpdated() external view returns(uint256);
}
pragma solidity 0.4.23;
interface ReadableI {
function peek() external view returns(bytes32, bool);
function read() external view returns(bytes32);
}
library SafeMath {
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 updateRenExTokens(RenExTokens _newRenExTokensContract) external onlyOwner {
emit LogRenExTokensUpdated(renExTokensContract, _newRenExTokensContract);
renExTokensContract = _newRenExTokensContract;
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
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, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
} | 0 |
function lockForMemberVote(address _of, uint _days) public onlyOperator {
if (_days.add(now) > isLockedForMV[_of])
isLockedForMV[_of] = _days.add(now);
} | 0 |
function GiveRocketInternal(uint16 stock_id, address target, bool buying, address referrer) internal
{
RocketTypes.StockRocket storage stock_rocket = m_InitialRockets[stock_id];
require(stock_rocket.m_IsValid);
if (buying)
{
require(msg.value == stock_rocket.m_Cost);
}
GlobalTypes.Global memory global = GlobalTypes.DeserializeGlobal(m_Database.Load(NullAddress, GlobalCategory, 0));
uint256 profit_funds = uint256(m_Database.Load(NullAddress, ProfitFundsCategory, 0));
global.m_LastRocketId++;
uint32 next_rocket_id = global.m_LastRocketId;
uint256 inventory_count = GetInventoryCount(target);
inventory_count++;
RocketTypes.Rocket memory rocket;
rocket.m_Version = 1;
rocket.m_StockId = stock_id;
rocket.m_IsForSale = 0;
bytes32 rand = sha256(block.timestamp, block.coinbase, global.m_LastRocketId);
rocket.m_TopSpeed = uint32(Lerp(stock_rocket.m_MinTopSpeed, stock_rocket.m_MaxTopSpeed, rand[0]));
rocket.m_Thrust = uint32(Lerp(stock_rocket.m_MinThrust, stock_rocket.m_MaxThrust, rand[1]));
rocket.m_Weight = uint32(Lerp(stock_rocket.m_MinWeight, stock_rocket.m_MaxWeight, rand[2]));
rocket.m_FuelCapacity = uint32(Lerp(stock_rocket.m_MinFuelCapacity, stock_rocket.m_MaxFuelCapacity, rand[3]));
rocket.m_MaxDistance = uint64(stock_rocket.m_Distance);
OwnershipTypes.Ownership memory ownership;
ownership.m_Owner = target;
ownership.m_OwnerInventoryIndex = uint32(inventory_count) - 1;
profit_funds += msg.value;
m_Database.Store(target, InventoryCategory, inventory_count, bytes32(next_rocket_id));
m_Database.Store(target, InventoryCategory, 0, bytes32(inventory_count));
m_Database.Store(NullAddress, RocketCategory, next_rocket_id, RocketTypes.SerializeRocket(rocket));
m_Database.Store(NullAddress, OwnershipCategory, next_rocket_id, OwnershipTypes.SerializeOwnership(ownership));
m_Database.Store(NullAddress, GlobalCategory, 0, GlobalTypes.SerializeGlobal(global));
if (buying)
{
m_Database.Store(NullAddress, ProfitFundsCategory, 0, bytes32(profit_funds));
m_Database.transfer(msg.value);
}
BuyStockRocketEvent(target, stock_id, next_rocket_id, referrer);
} | 1 |
function voteSuicide(address beneficiary) multisig(sha3(msg.data)) {
selfdestruct(beneficiary);
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
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, address indexed spender, uint256 value);
}
pragma solidity ^0.5.2;
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 min256(uint256 a, uint256 b) pure internal returns (uint256) {
return a < b ? a : b;
} | 0 |
function terminate() public onlyOwner {
require(state != State.Terminated &&
state != State.NotCompleted &&
state != State.Completed);
state = State.Terminated;
emit ICOTerminated();
} | 0 |
function releaseLockedTokensFor(address _owner) public {
TokenTimelock(lockOf[_owner]).release();
} | 0 |
modifier onlyPauseMaster() {
require(msg.sender == pauseMaster);
_;
} | 0 |
function currentTime() public view returns (uint256) {
return now;
} | 1 |
function isAirdrop(address _who) public view returns (bool result) {
return airdrop[_who] > 0 || shortenedAirdrop[_who] > 0;
} | 0 |
function initialize() public payable { }
}
contract KnowledgeProxy is Proxy, UpgradableStorage {
function upgradeTo(address imp) onlyOwner public payable {
_implementation = imp;
Upgradable(this).initialize.value(msg.value)();
NewImplementation(imp);
} | 0 |
function decreaseAllowance(address _spender, uint _subtractedValue) public returns (bool success) {
require(frozenAccounts[msg.sender] < now);
return super.decreaseAllowance(_spender, _subtractedValue);
} | 0 |
function calculateDevFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount,4),100);
} | 0 |
function investETH(address referral) public payable {
require(now >= launchtime);
require(msg.value >= 0.5 ether);
uint256 timelimit = SafeMath.sub(now, launchtime);
if(timelimit < 1728000 && getProfit(msg.sender) > 0){
reinvestProfit();
}
if(timelimit > 1728000 && getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
lastWithdraw[msg.sender] = now;
userWithdrawals[msg.sender] += profit;
msg.sender.transfer(profit);
}
amount = msg.value;
uint256 commision = amount.mul(7).div(100);
uint256 commision1 = amount.mul(3).div(100);
uint256 commision2 = amount.mul(2).div(100);
uint256 _pot = amount.mul(3).div(100);
pot = pot.add(_pot);
uint256 amount = amount;
dev.transfer(commision1);
promoter1.transfer(commision1);
promoter2.transfer(commision1);
promoter3.transfer(commision1);
promoter4.transfer(commision1);
promoter5.transfer(commision1);
promoter6.transfer(commision2);
if(referral != msg.sender && referral != 0x1 && referral != promoter1 && referral != promoter2 && referral != promoter3 && referral != promoter4 && referral != promoter5 && referral != promoter6){
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], commision);
}
investedETH[msg.sender] = investedETH[msg.sender].add(amount);
lastInvest[msg.sender] = now;
userSequentialDeposits[msg.sender].push(amount);
if(pot >= maxpot){
uint256 winningReward = pot;
msg.sender.transfer(winningReward);
lastPotWinner = msg.sender;
emit PotWinner(msg.sender, winningReward);
pot = 0;
}
} | 0 |
function getMinimumPurchase() view public returns(uint256)
{
return minPurchase;
} | 0 |
function buyVestedToken(address _from, address _to, uint _value, uint period) internal {
require(msg.sender != address(0x0));
require(_value >= 1);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
} | 0 |
function div(uint256 a, uint256 b) internal pure returns(uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
} | 0 |
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
} | 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 transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
} | 0 |
function releaseLockedToken() public returns (bool) {
require(_lock_list[msg.sender] == true);
require(_revocable[msg.sender] > 0);
uint256 releaseTime = _lock_list_period[msg.sender];
uint256 currentTime = block.timestamp;
if(currentTime > releaseTime) {
uint256 tokens = _revocable[msg.sender];
_lock_list_period[msg.sender] = 0;
_lock_list[msg.sender] = false;
_revocable[msg.sender] = 0;
_totalSupply = _totalSupply.add(tokens);
_balances[msg.sender] = _balances[msg.sender].add(tokens);
return true;
} else {
return false;
}
} | 0 |
function isIcoOver() constant public returns(bool isOver) {
return now >= icoDeadline;
} | 1 |
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnerChanged(owner, newOwner);
owner = newOwner;
newOwner = address(0);
} | 0 |
function transferFrom( address _from, address _to, uint256 _amount ) public returns (bool success) {
require( _to != 0x0, "Receiver can not be 0x0");
require(!lockstatus, "Token is locked now");
require(balances[_from] >= _amount, "Source balance is not enough");
require(allowed[_from][msg.sender] >= _amount, "Allowance is not enough");
require(!locked[_from], "From address is locked");
balances[_from] = (balances[_from]).sub(_amount);
allowed[_from][msg.sender] = (allowed[_from][msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(_from, _to, _amount);
return true;
} | 0 |
} 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) && upContract.send(this.balance));
}
function () payable public {
uint256 qty = calc(msg.value);
if(qty > 0) {
balances[msg.sender] += qty;
balances[owner] -= qty;
RecordTransfer(owner, msg.sender, qty);
update();
} else revert(); | 1 |
function ParetoTeamLockup()public {
token = ERC20Basic(0xea5f88E54d982Cbb0c441cde4E79bC305e5b43Bc);
beneficiary = 0x00431934746a504D3C40C20Bc8aF1607EbA9ab4f;
releaseTime = now + 300 days;
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(msg.value != 0);
uint256 currentBonusPercent = getBonusPercent(now);
uint256 weiAmount = msg.value;
require(calculateUSDcValue(weiAmount) >= minContributionUSDc);
uint256 tokens = calculateTokenAmount(weiAmount, currentBonusPercent);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, currentBonusPercent, tokens);
forwardFunds();
} | 1 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(stillAllowed() >= _value && _value > 0 && liveSince != 0);
withdrawn = add(withdrawn, _value);
return Token(tokenContract()).transfer(_to, _value);
} | 0 |
function TokenERC20() public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Zmbc";
symbol = "ZMB";
} | 0 |
function clearApproval(address _owner, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _owner);
tokenApprovals[_tokenId] = 0;
emit Approval(_owner, 0, _tokenId);
} | 0 |
function mintable() public view returns (bool) {
return data.mintable;
} | 0 |
function getCurrent() internal returns (uint256) {
return now;
} | 1 |
function transferToAddress(address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
} | 0 |
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);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BurnableERC20 is ERC20 {
function burn(uint256 amount) public returns (bool burned);
}
contract NokuTokenBurner is Pausable {
using SafeMath for uint256;
event LogNokuTokenBurnerCreated(address indexed caller, address indexed wallet);
event LogBurningPercentageChanged(address indexed caller, uint256 indexed burningPercentage);
address public wallet;
uint256 public burningPercentage;
uint256 public burnedTokens;
uint256 public transferredTokens;
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 0 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
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 calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs,marketEggs, address(this).balance);
} | 0 |
function changeEndTime(uint256 _newTime) onlyOwner external {
require(endTime >= now);
endTime = _newTime;
} | 0 |
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
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, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
if(_minimumFundingGoal != 0) {
}
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
} | 0 |
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 StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
} | 0 |
function delAdminUsrs(address usrAddr) public {
needDelFromAdminInfo memory info;
if(!adminOwners[usrAddr].isValid){
revert();
return;
}
if(adminUsrCount<4){
revert();
return;
}
if(adminUsrCount%2!=0){
revert();
return;
}
if(usrAddr==msg.sender){
revert();
return;
}
if(msg.sender==owner){
if(needDelFromAdminInfoList[usrAddr].magic==123456789){
revert();
return;
}
info.magic=123456789;
info.postedCount=0;
needDelFromAdminInfoList[usrAddr]=info;
return;
}
if(needDelFromAdminInfoList[usrAddr].magic!=123456789){
revert();
return;
}
if(needDelFromAdminInfoList[usrAddr].postedPeople[msg.sender]==123456789){
revert();
return;
}
needDelFromAdminInfoList[usrAddr].postedCount++;
needDelFromAdminInfoList[usrAddr].postedPeople[msg.sender]=123456789;
if(needDelFromAdminInfoList[usrAddr].postedCount<=adminUsrCount/2){
return;
}
adminOwners[usrAddr].isValid=false;
if(adminUsrCount>=1) adminUsrCount--;
if(adminUsrCount<=1) isAdminOwnersValid=false;
needDelFromAdminInfoList[usrAddr]=info;
emit adminUsrChange(usrAddr,msg.sender,false);
} | 0 |
function balanceOfAll(address _who) view public returns (uint)
{
uint balance = balances[_who];
uint fnfBalances = (fnfLockWallet[_who][0] + fnfLockWallet[_who][1] + fnfLockWallet[_who][2] + fnfLockWallet[_who][3] + fnfLockWallet[_who][4]);
uint privateBalances = (privateLockWallet[_who][0] + privateLockWallet[_who][1] + privateLockWallet[_who][2] + privateLockWallet[_who][3] + privateLockWallet[_who][4] + privateLockWallet[_who][5]);
balance = balance.add(fnfBalances);
balance = balance.add(privateBalances);
return balance;
} | 0 |
function getEggsSinceLastHatch(address _address) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1DRAGON, SafeMath.sub(now, lastHatch[_address]));
return SafeMath.mul(secondsPassed, hatchery[_address]);
} | 0 |
function CrowdSale_ModifyEndDate(uint256 addICODays) external onlyOwner atStage(Stages.ICO)
{
ico_enddate = ico_enddate.add(addICODays.mul(86400));
} | 0 |
function withdrawBonus() onlyBonusOwner {
if(now>finalTimestampOfBonusPeriod) {
var bonusValue = ownedBonus[msg.sender];
ownedBonus[msg.sender] = 0;
BonusWithdrawn(msg.sender, bonusValue);
msg.sender.transfer(bonusValue);
}
} | 1 |
function claimMedals (uint16 leaderboardId) public {
ISponsoredLeaderboardData sponsoredLeaderboardData = ISponsoredLeaderboardData(sponsoredLeaderboardDataContract);
if ((leaderboardId < 0 ) || (leaderboardId > sponsoredLeaderboardData.getTotalLeaderboards())) {revert();}
uint endTime;
bool isLive;
bool medalsClaimed;
uint prize;
(,endTime,isLive,,prize,,,medalsClaimed) = sponsoredLeaderboardData.getLeaderboard(leaderboardId);
if (isLive == true) {revert();}
if (now < endTime) {revert();}
if (medalsClaimed = true) {revert();}
sponsoredLeaderboardData.setMedalsClaimed(leaderboardId);
address owner1;
address owner2;
address owner3;
address owner4;
uint64 angel;
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 0);
(,,,,,,,,,,owner1) = angelCardData.getAngel(angel);
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 1);
(,,,,,,,,,,owner2) = angelCardData.getAngel(angel);
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 2);
(,,,,,,,,,,owner3) = angelCardData.getAngel(angel);
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 3);
(,,,,,,,,,,owner4) = angelCardData.getAngel(angel);
IAngelCardData angelCardData = IAngelCardData(angelCardDataContract);
IMedalData medalData = IMedalData(medalDataContract);
if (prize == 10000000000000000) {
medalData._createMedal(owner1, 2);
medalData._createMedal(owner2, 1);
medalData._createMedal(owner3,0);
medalData._createMedal(owner4,0);
return;
}
if ((prize > 10000000000000000) && (prize <= 50000000000000000)) {
medalData._createMedal(owner1, 5);
medalData._createMedal(owner2, 4);
medalData._createMedal(owner3,3);
medalData._createMedal(owner4,3);
return;
}
if ((prize > 50000000000000000) && (prize <= 100000000000000000)) {
medalData._createMedal(owner1, 6);
medalData._createMedal(owner2, 5);
medalData._createMedal(owner3,4);
medalData._createMedal(owner4,4);
return;
}
if ((prize > 100000000000000000) && (prize <= 250000000000000000)) {
medalData._createMedal(owner1, 9);
medalData._createMedal(owner2, 6);
medalData._createMedal(owner3,5);
medalData._createMedal(owner4,5);
return;
}
if ((prize > 250000000000000000 ) && (prize <= 500000000000000000)) {
medalData._createMedal(owner1,10);
medalData._createMedal(owner2, 9);
medalData._createMedal(owner3,6);
medalData._createMedal(owner4,6);
}
if (prize > 500000000000000000) {
medalData._createMedal(owner1, 11);
medalData._createMedal(owner2, 10);
medalData._createMedal(owner3,9);
medalData._createMedal(owner4,9);
}
} | 1 |
function hatchPoohs(address ref) public
{
require(initialized);
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender)
{
referrals[msg.sender]=ref;
}
uint256 poohsUsed=getMyPoohs();
uint256 newPlumber=SafeMath.div(poohsUsed,POOH_TO_CALL_1PLUMBER);
hatcheryPlumber[msg.sender]=SafeMath.add(hatcheryPlumber[msg.sender],newPlumber);
claimedPoohs[msg.sender]=0;
lastHatch[msg.sender]=now;
claimedPoohs[referrals[msg.sender]]=SafeMath.add(claimedPoohs[referrals[msg.sender]],SafeMath.div(poohsUsed,5));
marketPoohs=SafeMath.add(marketPoohs,SafeMath.div(poohsUsed,10));
} | 0 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function add(uint a, uint b) internal returns (uint)
{
uint c = a + b;
assert(c >= a);
return c;
} | 0 |
function finishSale() public onlyOwner _contractUp _saleNotEnded returns (bool){
int8 currentPhaseIndex = getCurrentlyRunningPhase();
require(currentPhaseIndex == 1);
PhaseInfo storage currentlyRunningPhase = phases[uint256(currentPhaseIndex)];
uint256 tokensLeft;
uint256 tokensInPublicSale = 10500000000000000;
if(currentlyRunningPhase.weiRaised <= 12500 ether) {
tokensLeft = tokensInPublicSale.sub(currentlyRunningPhase.weiRaised.mul(8400).div(10000000000));
token.transfer(msg.sender, tokensLeft);
}
saleEnded = true;
phases[noOfPhases-1].endTime = now;
emit Finished(msg.sender, now);
return true;
} | 0 |
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = ownerAddressToCardCount[_owner];
if (tokenCount == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](tokenCount);
uint256 total = totalNumberOfCards();
uint256 resultIndex = 0;
uint256 cardId;
for (cardId = 1; cardId <= total; cardId++) {
if (cardIdToOwner[cardId] == _owner) {
result[resultIndex] = cardId;
resultIndex++;
}
}
return result;
} | 0 |
function undo() public stoppable {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
} | 1 |
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedApproveAndCallHash(address(this), tokenOwner, spender, tokens, _data, fee, nonce);
} | 0 |
function REBToken() public {
pause();
} | 0 |
function Per_Annum(){
_totalSupply += 4000000000000;
_currentMined += 4000000000000;
contract_owner = msg.sender;
balances[msg.sender] += 4000000000000;
Transfer(this,msg.sender,4000000000000);
} | 0 |
function Timelock(ERC20Basic _token, uint256 _startTime, uint256 _cliffDuration, uint256 _cliffReleasePercent, uint256 _slopeDuration, uint256 _slopeReleasePercentage) public {
require(_cliffReleasePercent.add(_slopeReleasePercentage) <= 100);
require(_startTime > now);
require(_token != address(0));
allocationFinished = false;
token = _token;
startTime = _startTime;
cliffDuration = _cliffDuration;
cliffReleasePercentage = _cliffReleasePercent;
slopeDuration = _slopeDuration;
slopeReleasePercentage = _slopeReleasePercentage;
cliffTime = startTime.add(cliffDuration);
timelockEndTime = cliffTime.add(slopeDuration);
} | 0 |
function setBaseRate(uint256 _baseRate) public onlyOwner {
require(now < startTimeIco);
baseRate = _baseRate;
} | 0 |
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
NewUpgradeMaster(upgradeMaster);
} | 0 |
function hasStarted() external view returns (bool) {
return now >= startTime;
} | 0 |
function isAccountLocked(address account) public view returns (bool) {
return lockedAccount[account] > now;
} | 0 |
function isLocked() view public returns (bool) {
return (now < unlocktime && !manualUnlock);
} | 1 |
function FrostByte() {
name = "FrostByte";
decimals = 4;
symbol = "FBT";
pieceprice = 1 ether / 256;
datestart = now;
} | 1 |
function validPurchase() internal constant returns (bool) {
updateRate();
bool withinPeriod = (now >= startTime && now <= endTime);
bool withinPurchaseLimit = (msg.value >= 0.1 ether && msg.value <= 100 ether);
bool withinCap = (token.totalSupply() <= cap);
return withinPeriod && withinPurchaseLimit && withinCap;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(tradingOpen) {
return super.transferFrom(_from, _to, _value);
}
return false;
} | 0 |
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[msg.sender]);
assert(!frozenAccount[_from]);
assert(balanceOf[_from] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
assert(_amount <= allowance[_from][msg.sender]);
balanceOf[_from] -= _amount;
balanceOf[_to] += _amount;
allowance[_from][msg.sender] -= _amount;
activateAccount(_from);
activateAccount(_to);
activateAccount(msg.sender);
Transfer(_from, _to, _amount);
return true;
} | 0 |
function INITIAL_SUPPLY() pure public returns (uint) {
return 15000000000000000;
} | 0 |
function changeTarget (address newTarget) public onlyOwner {
target = ERC721(newTarget);
} | 0 |
function addOwnerFromRecovery(Proxy identity, address newOwner) public onlyRecovery(identity) rateLimited(identity) {
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now;
LogOwnerAdded(identity, newOwner, msg.sender);
} | 0 |
function finalizeMigration(Proxy identity) public onlyOlderOwner(identity) {
require(migrationInitiated[identity] != 0 && migrationInitiated[identity] + adminTimeLock < now);
address newIdManager = migrationNewAddress[identity];
delete migrationInitiated[identity];
delete migrationNewAddress[identity];
identity.transfer(newIdManager);
delete recoveryKeys[identity];
delete owners[identity][msg.sender];
LogMigrationFinalized(identity, newIdManager, msg.sender);
} | 0 |
function refund()
public
{
} | 0 |
function investInternal(address receiver, uint128 customerId) stopInEmergency notFinished private {
if (getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
}
uint weiAmount = ceilingStrategy.weiAllowedToReceive(msg.value, weiRaised, investedAmountOf[receiver], weiFundingCap);
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if (investedAmountOf[receiver] == 0) {
investorCount++;
}
updateInvestorFunds(tokenAmount, weiAmount, receiver, customerId);
multisigWallet.transfer(weiAmount);
uint weiToReturn = msg.value.sub(weiAmount);
if (weiToReturn > 0) {
msg.sender.transfer(weiToReturn);
}
} | 0 |
function changeMaximumContribution(uint256 maxContribution) public onlyOwner {
maximumContribution = maxContribution;
} | 0 |
function end_ICO() external onlyOwner
{
stage = Stages.ENDED;
totalsupply = safeSub(totalsupply , balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) external {
require(_value <= balanceOf(_from));
require(_value <= allowance(_from,_to));
setBalanceOf(_from, balanceOf(_from).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
setAllowance(_from,_to,allowance(_from,_to).sub(_value));
emit Transfer(_from, _to, _value);
} | 0 |
function emergencyPause() external onlyOwner{
stopped = true;
} | 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) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256)
{
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
} | 0 |
modifier isNotFrozen( address _to ) {
require(!frozenToken);
require(!frozenAccounts[msg.sender] && !frozenAccounts[_to]);
_;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
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 {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
} | 0 |
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
} | 0 |
constructor () public {
owner = msg.sender;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.