function
string | label
int64 |
|---|---|
function startNextPhase() public onlyOwner _saleNotEnded _contractUp _ifNotEmergencyStop returns(bool){
int8 currentPhaseIndex = getCurrentlyRunningPhase();
require(currentPhaseIndex == 0);
PhaseInfo storage currentlyRunningPhase = phases[uint256(currentPhaseIndex)];
uint256 tokensLeft;
uint256 tokensInPreICO = 7200000000000000;
if(currentlyRunningPhase.weiRaised <= 7500 ether) {
tokensLeft = tokensInPreICO.sub(currentlyRunningPhase.weiRaised.mul(9600).div(10000000000));
token.transfer(msg.sender, tokensLeft);
}
phases[0].endTime = now;
phases[1].startTime = now;
return true;
} | 0 |
function setEndsAt(uint time) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= time);
assert(startsAt <= time);
assert(now <= endsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
if (lastTierCntrct.finalized()) throw;
uint8 tierPosition = getTierPosition(this);
for (uint8 j = tierPosition + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
assert(time <= crowdsale.startsAt());
}
endsAt = time;
EndsAtChanged(endsAt);
} | 0 |
function setClosingTime(uint256 _closingTime) onlyOwner public {
require(_closingTime >= block.timestamp);
require(_closingTime >= openingTime);
closingTime = _closingTime;
} | 0 |
function withdrawContributorsTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
require(transferFrom(contributorsAllocation, _to, _amountWithDecimals));
} | 0 |
function setMinimumWeiAmount(uint256 newMinimumWeiAmount) onlyOwner public returns (bool) {
require(newMinimumWeiAmount > 0);
minimumWeiAmount = newMinimumWeiAmount;
return true;
} | 0 |
function getLostAndFoundMaster() internal view returns(address) {
return lost_and_found_master;
} | 0 |
function nameFor(address addr) returns (bytes32 name) {
return nameRegistry[addr];
} | 0 |
modifier withGasPriceLimit(uint256 _gasPriceLimit) {
require(tx.gasprice <= _gasPriceLimit, "gas price too high");
_;
} | 0 |
function close() onlyOwner {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
} | 0 |
function setTime(uint _time) public onlyOwner{
current_time = _time;
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
modifier updateDividends()
{
if(now - lastDividendsFetched > DIVIDEND_FETCH_TIME && totalSupply > 0) {
fetchDividendsFromP3X();
}
_;
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _token) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = ERC20(_token);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function addOwnerFromRecovery(address sender, Proxy identity, address newOwner) public
onlyAuthorized
onlyRecovery(identity, sender)
rateLimited(identity, sender)
{
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now;
LogOwnerAdded(identity, newOwner, sender);
} | 0 |
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 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 totalSupply()public view returns (uint total_Supply);
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract OTPPAY is ERC20
{ using SafeMath for uint256;
string public constant name = "OTPPAY";
string public constant symbol = "OTP";
uint8 public constant decimals = 18;
uint public _totalsupply = 1000000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn_PRE = 16000;
uint256 public _price_tokn_ICO1;
uint256 public _price_tokn_ICO2;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
uint256 refferaltoken;
bool stopped = false;
uint256 public pre_startdate;
uint256 public ico1_startdate;
uint256 public ico2_startdate;
uint256 pre_enddate;
uint256 ico1_enddate;
uint256 ico2_enddate;
uint256 maxCap_PRE;
uint256 maxCap_ICO1;
uint256 maxCap_ICO2;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
PREICO,
ICO1,
ICO2,
PAUSED,
ENDED
} | 0 |
function setUpgradeMaster(address new_master) private {
require(new_master != 0x0);
upgradeMaster = new_master;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
} | 0 |
function approve(address _spender, uint256 _value) external returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
} | 1 |
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
);
constructor(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 signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(eggValue,fee));
} | 0 |
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 getRunDetails(uint _heroId) external view returns (
uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState
) {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
(_heroPower,,,,) = edCoreContract.getHeroPower(genes, dungeonDifficulty);
_heroStrength = (genes / (32 ** 8)) % 32 + 1;
_heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
_heroHealth = heroIdToHealth[_heroId];
Monster memory monster = heroIdToMonster[_heroId];
_monsterCreationTime = monster.creationTime;
bool _dungeonRunEnded = monster.level > 0 && (
_heroHealth == 0 ||
now > _monsterCreationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime)
);
if (monster.level == 0) {
_heroHealth = _heroInitialHealth;
_monsterLevel = 1;
_monsterInitialHealth = monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 0;
} else if (_dungeonRunEnded) {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 3;
} else if (now > _monsterCreationTime + monsterFleeTime) {
if (monster.level + monsterStrength > _heroHealth) {
_heroHealth = 0;
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
} else {
_heroHealth -= monster.level + monsterStrength;
_monsterCreationTime += monsterFleeTime;
_monsterLevel = monster.level + 1;
_monsterInitialHealth = _monsterLevel * monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 1;
}
} else {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
}
} | 0 |
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveAndCallCheck(tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
} | 0 |
function marketWithdrawBid(uint256 tokenId) external returns(bool){
require (_exists(tokenId));
require (_tokenOwner[tokenId] != msg.sender);
bidInfo storage existingBid = marketBidInfoByIndex[tokenId];
require (existingBid.hasBid);
require (existingBid.bidder == msg.sender);
uint256 amount = existingBid.value;
marketPendingWithdrawals[existingBid.bidder] =
marketPendingWithdrawals[existingBid.bidder].add(amount);
marketBidInfoByIndex[tokenId] = bidInfo(false, tokenId, address(0), 0);
emit BidWithdrawn(tokenId, amount, msg.sender);
return true;
} | 0 |
constructor (string memory name, string memory symbol, uint8 decimals, uint256 supply, address treasury, uint256 initialUnlocked, uint256 monthlyUnlocked) public
ERC20Detailed(name, symbol, decimals)
{
_mint(treasury, supply);
require(initialUnlocked <= totalSupply(), "initialUnlocked too large");
require(monthlyUnlocked <= totalSupply(), "monthlyUnlocked too large");
_treasury = treasury;
_monthlyUnlocked = monthlyUnlocked;
_unlocked = initialUnlocked;
_calcTime = now;
} | 0 |
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
emit Mint(msg.sender, to, value);
return true;
} | 0 |
function payAltCoin(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
{
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, _value, _commission);
verifyDeal(_hashDeal, _sign);
bool result = streamityContractAddress.transferFrom(msg.sender, address(this), _value);
require(result == true);
startDealForUser(_hashDeal, _seller, _buyer, _commission, _value, true);
} | 0 |
function updateTokensPerEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateTokensPerEth") {
defaultTokensPerWei = _newValue;
recalcBonuses();
} | 0 |
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
} | 0 |
function balanceOf(address tokenowner) public constant returns (uint);
function allowance(address tokenowner, address spender) public constant returns (uint);
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
function issue(address to, uint tokencount) public;
}
contract UncursedToken is ERC20 {
string public symbol = "CB";
string public name = "Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
uint public birthBlock;
address public cursedContract = 0x0;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function UncursedToken() public {
birthBlock = block.number;
} | 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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
finalizeAgent.finalizeCrowdsale(token);
finalized = true;
Finalized();
} | 0 |
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
} | 0 |
function buyTokens() public payable whenNotPaused {
require(validPurchase());
uint256 tokens = 0;
uint256 amountPaid = calculateExcessBalance();
if(tokensRaised < limitTier1) {
tokens = amountPaid.mul(rate);
if(tokensRaised.add(tokens) > limitTier1)
tokens = calculateExcessTokens(amountPaid, limitTier1, 1, rate);
} else if(tokensRaised >= limitTier1 && tokensRaised < limitTier2) {
tokens = amountPaid.mul(rateTier2);
if(tokensRaised.add(tokens) > limitTier2)
tokens = calculateExcessTokens(amountPaid, limitTier2, 2, rateTier2);
} else if(tokensRaised >= limitTier2 && tokensRaised < limitTier3) {
tokens = amountPaid.mul(rateTier3);
if(tokensRaised.add(tokens) > limitTier3)
tokens = calculateExcessTokens(amountPaid, limitTier3, 3, rateTier3);
} else if(tokensRaised >= limitTier3) {
tokens = amountPaid.mul(rateTier4);
}
weiRaised = weiRaised.add(amountPaid);
uint256 tokensRaisedBeforeThisTransaction = tokensRaised;
tokensRaised = tokensRaised.add(tokens);
token.distributeICOTokens(msg.sender, tokens);
tokensBought[msg.sender] = tokensBought[msg.sender].add(tokens);
TokenPurchase(msg.sender, amountPaid, tokens);
numberOfTransactions = numberOfTransactions.add(1);
if(tokensRaisedBeforeThisTransaction > minimumGoal) {
walletB.transfer(amountPaid);
} else {
vault.deposit.value(amountPaid)(msg.sender);
if(goalReached()) {
vault.close();
}
}
checkCompletedCrowdsale();
} | 0 |
function normalizeShiftAmount(uint256 shift) internal pure returns (uint256)
{
require(shift >= 0 && shift <= 2, "You can't set more than 2 decimal places");
uint256 value = 100;
return value.mul(10 ** shift);
} | 0 |
function changeOwner(address newOwner) onlyOwner public {
require(newOwner != address(0));
require(newOwner != owner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function init(Data storage self, address owner, string symbol, string name, uint8 decimals, uint initialSupply, bool mintable, bool transferable) public {
require(!self.initialised);
self.initialised = true;
self.owner = owner;
self.symbol = symbol;
self.name = name;
self.decimals = decimals;
if (initialSupply > 0) {
self.balances[owner] = initialSupply;
self.totalSupply = initialSupply;
Mint(self.owner, initialSupply, false);
Transfer(address(0), self.owner, initialSupply);
}
self.mintable = mintable;
self.transferable = transferable;
} | 0 |
function transform() public {
TransformState state = getTransformState();
require(state == TransformState.ReadyToTransform || state == TransformState.Transforming);
uint tokens = balances[msg.sender];
uint investments = funds[msg.sender];
require(tokens > 0);
balances[msg.sender] = 0;
funds[msg.sender] = 0;
totalSupply = totalSupply.sub(tokens);
totalFunds = totalFunds.sub(investments);
totalTransformedTokens = totalTransformedTokens.add(tokens);
transformAgent.transformFrom(msg.sender, tokens, investments);
Transform(msg.sender, transformAgent, tokens, investments);
if(totalSupply == 0)
selfdestruct(owner);
} | 0 |
modifier onlyBefore() {
if (now > icoEndtime) {
revert();
}
_;
} | 1 |
function GStarToken() public {
owner = msg.sender;
totalSupply_ = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY;
currentTotalSupply = INITIAL_SUPPLY;
emit Transfer(address(0), owner, INITIAL_SUPPLY);
} | 0 |
function tokenFallback(address from, uint256 value, bytes) public {
require(msg.sender == auctusTokenAddress);
escrowedTokens = escrowedTokens.add(value);
emit Escrow(from, value);
} | 1 |
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
} | 0 |
function getBonus() public view returns(uint256){
uint256 invested = getInvested();
if(invested >= 0.5 ether && 4 ether >= invested){
return 0;
}else if(invested >= 4.01 ether && 7 ether >= invested){
return 20;
}else if(invested >= 7.01 ether && 10 ether >= invested){
return 40;
}else if(invested >= 10.01 ether && 15 ether >= invested){
return 60;
}else if(invested >= 15.01 ether){
return 99;
}
} | 0 |
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster memory monster = heroIdToMonster[_heroId];
uint currentLevel = monster.level;
uint heroCurrentHealth = heroIdToHealth[_heroId];
bool dungeonRunEnded;
if (currentLevel == 0) {
require(msg.value >= entranceFee);
entranceFeePool += entranceFee;
heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth);
monster = heroIdToMonster[_heroId];
heroIdToHealth[_heroId] = heroInitialHealth;
heroCurrentHealth = heroInitialHealth;
if (msg.value > entranceFee) {
msg.sender.transfer(msg.value - entranceFee);
}
} else {
require(heroCurrentHealth > 0);
dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime);
if (dungeonRunEnded) {
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
if (addToJackpot > 0) {
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
heroIdToRefundedFee[_heroId] += addToJackpot;
}
assert(addToJackpot <= entranceFee);
}
msg.sender.transfer(msg.value);
}
if (!dungeonRunEnded) {
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
}
} | 0 |
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {
return super.increaseAllowance(spender, addedValue);
} | 0 |
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
} | 0 |
function startEmergencyRelease() external {
emergencyReleaseSince[msg.sender] = block.timestamp + EMERGENCY_RELEASE_CHALLENGE_PERIOD;
emit StartEmergencyRelease(msg.sender);
} | 0 |
function timelockAccount(address target, uint releasetime) public onlyOwner {
uint r_time;
r_time = now + (releasetime * 1 days);
timelockAccounts[target] = r_time;
emit TimeLockFunds(target, r_time);
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
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 BioCoin(address _owner) UpgradeableToken(_owner) {
name = "BioCoin";
symbol = "BIOCOIN";
totalSupply = 1000000000000000000000000000;
decimals = 18;
balances[_owner] = totalSupply;
} | 0 |
function pause() onlyOwner whenNotPaused public returns (bool) {
paused = true;
emit Pause();
return true;
} | 0 |
function balanceOf(address who) constant returns(uint256);
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);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken {
function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )returns (address){}
function transfer ( address _address , uint256 amount ){}
function share()returns(uint256){}
function totalSupply()returns(uint256){}
function initialSupply()returns(uint256){}
}
contract Cents is ERC20 {
using strings for *;
string public standard = 'Token 1.0';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public _owner;
address public owner;
address public manager;
address public Centspooladdress;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address =>bool ) public accountFreeze;
uint accountCount;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
event FrozenFunds ( address target, bool frozen );
event TTLAccounts ( uint accounts );
event TTLSupply ( uint supply ) ;
event Burn(address indexed from, uint256 value);
function Cents() {
uint256 _initialSupply = 100000000 ;
uint8 decimalUnits = 0;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "Cents";
symbol = "Cents";
decimals = decimalUnits;
owner = msg.sender;
} | 0 |
function approve(address _spender, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function () {
throw;
} | 0 |
function symbol() constant returns (string) {
return _symbol;
} | 0 |
function isSane(CrowdsaleToken token) public constant returns (bool) {
return token.mintAgents(address(this)) && token.releaseAgent() == address(this);
} | 0 |
constructor(ERC20Interface _addressOfTokenUsedAsReward) public {
tokenReward = _addressOfTokenUsedAsReward;
owner = 0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98;
beneficiary = 0x8605409D35f707714A83410BE9C8025dcefa9faC;
emit LogFundingInitialized(owner);
} | 0 |
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
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 isContract(address _addr) view internal returns (bool) {
uint256 length;
if (_addr == address(0x0)) return false;
assembly {
length := extcodesize(_addr)
}
if(length > 0) {
return true;
} else {
return false;
}
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'DEBIT Coin Token';
string public symbol = 'DBC';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function emergencyRestart() external onlyOwner _contractUp {
require(ifEmergencyStop);
ifEmergencyStop = false;
emit SaleRestarted(msg.sender, now);
} | 0 |
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
assert(c / _a == _b);
return c;
} | 0 |
function reclaimToken(ERC20Basic _token) external onlyOwner {
uint256 balance = _token.balanceOf(this);
_token.safeTransfer(owner, balance);
} | 0 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_com = _com.add(_p3d.sub(_p3d / 2));
admin.transfer(_com);
_res = _res.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
} | 0 |
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
modifier isNotTimeLockedFrom( address _from ) {
require( now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]);
_;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining){
return approved[_owner][_spender];
} | 0 |
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) public returns (bool success) {
require(_from != address(0));
require(_to != address(0));
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 receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 110;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
} | 0 |
function canPegBeDecreased() external view returns(bool) {
return (daiContract.balanceOf(address(this)) <= address(this).balance.mul(etherPeg).div(50) && (now > pegMoveReadyTime));
} | 0 |
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 setAssetProxy(AssetProxyInterface _assetProxy) onlyRole('admin') returns(bool) {
require(address(assetProxy) == 0x0);
require(address(vesting) != 0x0);
assetProxy = _assetProxy;
assetProxy.approve(vesting, ((2 ** 256) - 1));
return true;
} | 0 |
function setTokenCountFromPreIco(uint256 value) public;
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
CryptoRoboticsToken public token;
ICOContract ico;
address public wallet;
uint256 public weiRaised;
uint256 public openingTime;
uint256 public closingTime;
bool public isFinalized = false;
uint public tokenPriceInWei = 105 szabo;
uint256 public cap = 1008 ether;
event Finalized();
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
} | 0 |
function time() public view returns (uint) {
return block.timestamp;
} | 0 |
function createTokenContract() internal returns (MintableToken) {
return new BlockbidMintableToken();
} | 0 |
function decimals()external view returns (uint8);
}
contract Vault is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
address public wallet;
event Withdrawn(address _wallet);
function Vault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
} | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function sellEggs() public{
require(initialized);
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
uint256 fee = devFee(eggValue);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
marketEggs = SafeMath.add(marketEggs, hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(eggValue, fee));
} | 0 |
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
} | 0 |
constructor() public {
manager = msg.sender;
nextWithdrawDayFoundation = now;
nextWithdrawDayCommunity = now;
nextWithdrawDayTeam = now;
} | 0 |
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
return withinPeriod && nonZeroPurchase && withinTokenLimit && minimumPurchase;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
constructor() public {
lock = now;
emit SetLock(0, now);
} | 0 |
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
} | 0 |
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
} | 0 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
function buy() public payable {
require(!requireCustomerId);
investInternal(msg.sender, 0);
} | 0 |
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
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 presaleWeiRaised = 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 newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
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 endSale() onlyManager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
for(uint i = 1; i <= teamVestingTime; i++)
{
teamVestingTimeAtSupply[i] = teamVestingTimeAtSupply[i].add(teamVestingSupplyPerTime);
}
for(uint i = 1; i <= advisorVestingTime; i++)
{
advisorVestingTimeAtSupply[i] = advisorVestingTimeAtSupply[i].add(advisorVestingSupplyPerTime);
}
} | 0 |
function bonuscalpre() private returns (uint256 cp)
{
uint bon = 8;
bonusCalculationFactor = (block.timestamp.sub(pre_startdate)).div(604800);
if(bonusCalculationFactor == 0)
{
bon = 8;
}
else{
bon -= bonusCalculationFactor* 8;
}
return bon;
} | 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)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function isCrowdsale() public pure returns (bool) {
return true;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
} | 0 |
function relayReceiveApproval(address _caller, address _spender, uint256 _amount, bytes _extraData) returns (bool success);
}
contract TokenBase is Owned {
bytes32 public standard = 'Token 0.1';
bytes32 public name;
bytes32 public symbol;
uint256 public totalSupply;
bool public allowTransactions;
event Approval(address indexed from, address indexed spender, uint256 amount);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address _to, uint256 _value) returns (bool success);
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function () {
throw;
} | 0 |
function finishMinting() public onlyMasterOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function balanceOf(address _owner) public constant returns (uint256){
return balanceOf[_owner];
} | 0 |
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
constructor() public {
daysOnline = block.timestamp;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.