function
string | label
int64 |
|---|---|
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
uint periodsPassed = ((now.sub(_startTime.add(MinimumHoldingPeriod))).div(Interval)).add(1);
percentage = periodsPassed.mul(25);
} | 0 |
function getAllowedAmountToContribute(address addr) view public returns(uint256) {
if (!whitelist[addr]._whitelisted) {
return 0;
} else if (now <= timeThatFinishGuaranteedPeriod) {
if (whitelist[addr]._shouldWaitGuaranteedPeriod) {
return 0;
} else {
if (whitelist[addr]._doubleValue) {
uint256 amount = maximumValueDuringGuaranteedPeriod * 2;
if (whitelist[addr]._unlimited || amount < maximumValueWithoutProofOfAddress) {
return amount;
} else {
return maximumValueWithoutProofOfAddress;
}
} else {
return maximumValueDuringGuaranteedPeriod;
}
}
} else {
if (whitelist[addr]._unlimited) {
return maximumValueAfterGuaranteedPeriod;
} else {
return maximumValueWithoutProofOfAddress;
}
}
} | 1 |
function updateOutstandingDividends(Shareholder storage shareholder)
private
{
uint256 dividendPointsDifference = totalDividendPoints.sub(shareholder.lastDividendPoints);
shareholder.lastDividendPoints = totalDividendPoints;
shareholder.outstandingDividends = shareholder.outstandingDividends
.add(dividendPointsDifference.mul(shareholder.tokens) / POINT_MULTIPLIER);
} | 0 |
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract NXX is ERC223, Pausable {
using SafeMath for uint256;
using ContractLib for address;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
} | 0 |
function changeEndDate(uint256 endTimeUnixTimestamp) public onlyOwner{
endTime = endTimeUnixTimestamp;
} | 0 |
function emergencyStop() external onlyOwner _contractUp _ifNotEmergencyStop {
ifEmergencyStop = true;
emit SaleStopped(msg.sender, now);
} | 0 |
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function mintApproveReset(address _address) public onlyOwner {
_mintApproveClear(_address);
} | 0 |
function getBlockTimestamp() internal constant returns (uint256) {
return block.timestamp;
} | 1 |
function EIForceCoin () public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
transfer(WALLET_FOUNDER, ALLOC_FOUNDER);
} | 0 |
function getLockedAmount_simus(address _simu)
public
constant
returns (uint256)
{
uint256 simuDate = simus_simuDate[_simu];
uint256 lockedAmt = simus_locked[_simu];
if (now <= simuDate + (30 * 1 days)) {return lockedAmt;}
if (now <= simuDate + (30 * 2 days)) {return lockedAmt.mul(9).div(10);}
if (now <= simuDate + (30 * 3 days)) {return lockedAmt.mul(8).div(10);}
if (now <= simuDate + (30 * 4 days)) {return lockedAmt.mul(7).div(10);}
if (now <= simuDate + (30 * 5 days)) {return lockedAmt.mul(6).div(10);}
if (now <= simuDate + (30 * 6 days)) {return lockedAmt.mul(5).div(10);}
if (now <= simuDate + (30 * 7 days)) {return lockedAmt.mul(4).div(10);}
if (now <= simuDate + (30 * 8 days)) {return lockedAmt.mul(3).div(10);}
if (now <= simuDate + (30 * 9 days)) {return lockedAmt.mul(2).div(10);}
if (now <= simuDate + (30 * 10 days)) {return lockedAmt.mul(1).div(10);}
return 0;
} | 0 |
function burn (uint256 _burntAmount) public returns (bool success) {
require(balances[msg.sender] >= _burntAmount && _burntAmount > 0);
balances[msg.sender] = balances[msg.sender].sub(_burntAmount);
totalToken = totalToken.sub(_burntAmount);
tokenDestroyed = tokenDestroyed.add(_burntAmount);
require (tokenDestroyed <= 100000000000000000000000000);
Transfer(address(this), 0x0, _burntAmount);
Burn(msg.sender, _burntAmount, block.timestamp);
return true;
} | 1 |
function calculateUnLockerGMI(address userAddr) private isActivated()
view returns(uint256, uint256, uint256, uint256, uint256) {
uint256 unlockedCount = 0;
uint256 currentTakeGMI = 0;
uint256 userTakenTime = takenTime[userAddr];
uint256 userLockedGMI = lockList[userAddr];
unlockedCount = safeDiv(safeSub(now, activatedTime), timeInterval);
if(unlockedCount == 0) {
return (0, unlockedCount, unlockedGMI, userLockedGMI, userTakenTime);
}
if(unlockedCount > unLockedAmount) {
unlockedCount = unLockedAmount;
}
uint256 unlockedGMI = safeDiv(safeMul(userLockedGMI, unlockedCount), unLockedAmount);
currentTakeGMI = safeSub(unlockedGMI, takenAmount[userAddr]);
if(unlockedCount == unLockedAmount) {
currentTakeGMI = safeSub(userLockedGMI, takenAmount[userAddr]);
}
return (currentTakeGMI, unlockedCount, unlockedGMI, userLockedGMI, userTakenTime);
} | 0 |
function addToken(address _to, uint256 _tokenId) private {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
memeData[_tokenId].owner = _to;
uint256 length = balanceOf(_to);
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
totalTokens = totalTokens.add(1);
} | 0 |
function MintableToken(uint _initialSupply, address _multisig, bool _mintable) internal {
require(_multisig != address(0));
require(_mintable || _initialSupply != 0);
if (_initialSupply > 0)
mintInternal(_multisig, _initialSupply);
mintingFinished = !_mintable;
} | 0 |
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
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 releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
} | 0 |
function buyFunderSmartToken (string _email, string _code) payable public returns (bool) {
require(FunderSmartTokenAddress != 0x0);
require(FundersTokenCentral != 0x0);
require(msg.value >= 1 ether);
require(now >= startTime && now <= endTime);
require(soldTokenValue <= preSaleHardCap);
uint256 _tokenValue = msg.value * oneEtherIsHowMuchFST;
if (keccak256(_code) == 0xde7683d6497212fbd59b6a6f902a01c91a09d9a070bba7506dcc0b309b358eed) {
_tokenValue = _tokenValue * 135 / 100;
}
if (keccak256(_code) == 0x65b236bfb931f493eb9e6f3db8d461f1f547f2f3a19e33a7aeb24c7e297c926a) {
_tokenValue = _tokenValue * 130 / 100;
}
if (keccak256(_code) == 0x274125681e11c33f71574f123a20cfd59ed25e64d634078679014fa3a872575c) {
_tokenValue = _tokenValue * 125 / 100;
}
if (FunderSmartTokenAddress.call(bytes4(keccak256("transferFrom(address,address,uint256)")), FundersTokenCentral, msg.sender, _tokenValue) != true) {
revert();
}
BuyEvent(msg.sender, _email, msg.value, _tokenValue);
soldTokenValue = soldTokenValue + _tokenValue;
return true;
} | 0 |
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
} | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
throw;
}
if (value == 0) throw;
balances[msg.sender] = safeSub(balances[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
} | 0 |
function setTokenRate(uint256 _newRate) external onlyOwner
{
rate = _newRate;
} | 0 |
function safeWithdrawal() public {
require(withdrawlsEnabled);
require(now > icoEndUnix);
uint256 weiAmount = paidIn[msg.sender];
uint256 purchasedTokenAmount = paidIn[msg.sender] * (10 ** uint256(decimals)) / buyPrice;
if(purchasedTokenAmount > balanceOf[msg.sender]) { purchasedTokenAmount = balanceOf[msg.sender]; }
if(weiAmount > balanceOf[msg.sender] * buyPrice / (10 ** uint256(decimals))) { weiAmount = balanceOf[msg.sender] * buyPrice / (10 ** uint256(decimals)); }
if (purchasedTokenAmount > 0 && weiAmount > 0) {
_transfer(msg.sender, this, purchasedTokenAmount);
if (msg.sender.send(weiAmount)) {
paidIn[msg.sender] = 0;
emit FundTransfer(msg.sender, weiAmount);
} else {
_transfer(this, msg.sender, purchasedTokenAmount);
}
}
} | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address tokenOwner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 value
);
}
contract LTLNN is ERC20, Ownable {
using SafeMath for uint256;
string public name = "Lawtest Token";
string public symbol ="LTLNN";
uint8 public decimals = 2;
uint256 initialSupply = 5000000;
uint256 saleBeginTime = 1557824400;
uint256 saleEndTime = 1557835200;
uint256 tokensDestructTime = 1711929599;
mapping (address => uint256) private _balances;
mapping (address => mapping(address => uint)) _allowed;
uint256 private _totalSupply;
uint256 private _amountForSale;
event Mint(address indexed to, uint256 amount, uint256 amountForSale);
event TokensDestroyed();
constructor() public {
_balances[address(this)] = initialSupply;
_amountForSale = initialSupply;
_totalSupply = initialSupply;
} | 0 |
function add(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
require(z >= x && z>=y);
return z;
} | 0 |
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) public {
target = _target;
} | 0 |
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
} | 0 |
function withdraw() public{
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
} | 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 transferFrom(address _from, address _to, uint _value) public validateAddress(_to) isNotTimeLockedFrom(_from) isNotFrozenFrom(_from, _to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
function isLocked() constant returns (bool) {
return (now < unlockTime);
} | 1 |
function TokenTimelock(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
constructor (uint256 cap) internal {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
} | 0 |
function sendWinnings() public {
require(now > lastTimestamp + 1 days);
uint256 toWinner;
uint256 toDev;
if (address(this).balance > 0) {
uint256 totalPot = address(this).balance;
toDev = totalPot.div(100);
toWinner = totalPot.sub(toDev);
dev.transfer(toDev);
currentWinner.transfer(toWinner);
}
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
emit NewRound(toWinner, highScore);
} | 0 |
function setNewRequest(string memory pname, string memory pubkey) public returns (uint) {
bool checkProduct = checkProductExist(pname);
if(checkProduct){
string memory wid = appendString(WallettoString(msg.sender),pname);
bool cwallet = checkWalletexist(wid);
if(cwallet){
revert();
} else {
if(balanceOf[msg.sender] >= newProduct[pname].price) {
transfer(fundsWallet, newProduct[pname].price);
RWlist[wid]=true;
rlist[pname].push(Requesters(true,now, pubkey, msg.sender));
listofproducts.push(wid) -1;
return rlist[pname].length - 1;
} else {
revert();
}
}
} else {
revert();
}
} | 0 |
function allocate(address _beneficiary, uint256 _value) public onlyOwner returns (bool success) {
require (isActive == true);
require (_value > 0);
require (msg.sender == owner);
require(_beneficiary != address(0));
uint256 checkedSupply = _raised.add(_value);
require(checkedSupply <= tokenCreationCap);
_raised = checkedSupply;
bool sent = ERC20Interface(token).mint(_beneficiary, _value);
require(sent);
emit TokenAllocated(this, _beneficiary, _value);
return true;
} | 0 |
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
} | 0 |
function relaxFundingCap(uint newCap, uint weiRaised) public constant returns (uint) {
if (newCap > weiRaised) return newCap;
else return weiRaised.div(chunkedWeiMultiple).add(1).mul(chunkedWeiMultiple);
} | 0 |
function buyTokens(address beneficiary) public whenNotPaused payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
weiRaised = weiRaised.add(weiAmount);
investments[beneficiary] = investments[beneficiary].add(weiAmount);
emit Investment(msg.sender, beneficiary, weiAmount, msg.data);
forwardFunds();
} | 0 |
function setLockup_dakehus(address _dakehu, uint256 _value, uint256 _dakehuDate)
public
onlyOwner
{
require(_dakehu != address(0));
dakehus_locked[_dakehu] = _value;
dakehus_dakehuDate[_dakehu] = _dakehuDate;
UpdatedLockingState("dakehu", _dakehu, _value, _dakehuDate);
} | 0 |
function close() public onlyOwner beforeEnd {
uint256 saleTokensToBurn = balances[owner];
balances[owner] = 0;
totalSupply = totalSupply.sub(saleTokensToBurn);
Burn(owner, saleTokensToBurn);
uint256 foundationTokens = 33000000 * 10**uint256(decimals);
totalSupply = totalSupply.add(foundationTokens);
balances[foundationAddress] = foundationTokens;
uint256 teamTokens = 12000000 * 10**uint256(decimals);
totalSupply = totalSupply.add(teamTokens);
uint256 teamTokensY1 = 2400000 * 10**uint256(decimals);
TokenTimelock year1Lock = new TokenTimelock(this, omniTeamAddress, date01Jan2019);
year1LockAddress = address(year1Lock);
balances[year1LockAddress] = teamTokensY1;
uint256 teamTokensY2 = 2400000 * 10**uint256(decimals);
TokenTimelock year2Lock = new TokenTimelock(this, omniTeamAddress, date01Jan2020);
year2LockAddress = address(year2Lock);
balances[year2LockAddress] = teamTokensY2;
uint256 teamTokensY3 = 2400000 * 10**uint256(decimals);
TokenTimelock year3Lock = new TokenTimelock(this, omniTeamAddress, date01Jan2021);
year3LockAddress = address(year3Lock);
balances[year3LockAddress] = teamTokensY3;
uint256 teamTokensY4 = 2400000 * 10**uint256(decimals);
TokenTimelock year4Lock = new TokenTimelock(this, omniTeamAddress, date01Jan2022);
year4LockAddress = address(year4Lock);
balances[year4LockAddress] = teamTokensY4;
uint256 teamTokensY5 = 2400000 * 10**uint256(decimals);
TokenTimelock year5Lock = new TokenTimelock(this, omniTeamAddress, date01Jan2023);
year5LockAddress = address(year5Lock);
balances[year5LockAddress] = teamTokensY5;
tokenSaleClosed = true;
} | 0 |
function transfer(address to, uint value) public returns (bool success) {
require(_balances[msg.sender] >= value);
if (to == BXIT || to == address(this)) {
_balances[msg.sender] = _balances[msg.sender].sub(value);
supply = supply.sub(value);
emit Transfer(msg.sender, address(0), value);
burn(msg.sender, value);
return true;
} else {
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
}
} | 0 |
function withdrawInvestments() external onlyOwner{
uint amount = address(this).balance;
getOwner().transfer(amount * 1 wei);
emit InvestmentsWithdrawn(amount, block.timestamp);
} | 0 |
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
} | 1 |
function createAudit(uint _stake, uint _endTimeInDays, uint _maxAuditors) external payable onlyOwner {
uint endTime = _endTimeInDays * 1 days;
require(endTime < maxAuditDuration);
require(block.timestamp + endTime * 1 days > block.timestamp);
require(msg.value > 0 && _maxAuditors > 0 && _stake > 0);
Audit memory audit;
audit.status = AuditStatus.New;
audit.owner = msg.sender;
audit.id = audits.length;
audit.totalReward = msg.value;
audit.remainingReward = audit.totalReward;
audit.stake = _stake;
audit.endTime = block.timestamp + endTime;
audit.maxAuditors = _maxAuditors;
audits.push(audit);
emit CreatedAudit(audit.id);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
_transfer(msg.sender, _to, _value);
return true;
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value < m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function changeSubmissionPrice(uint256 _newPrice) external onlyAdmin() {
submissionPrice = _newPrice;
} | 0 |
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);
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 FoundersContract {
using SafeMath for uint256;
ROBOToken public token;
uint64 public freezOne = 1538352000;
uint64 public freezTwo = 1554076800;
mapping(address => uint256) public balances_freez_one;
mapping(address => uint256) public balances_freez_two;
address muhtov = 0x0134111c40D59E8476FfabB7D0B2ED6F86513E6e;
address scherbakov = 0x7B8E11cFE4E7aFec83276002dD246a71a4bD51EC;
address sattarova = 0xFDA80FA2b42063F5c2Aa14C5da18cBBDfC2f72F8;
address roma_kiev = 0x5edc1959772b3C63310f475E04a72CdA1733D6A4;
address iliya = 0x45F8da4a6f465345DdaF003094C2B9D11254B15D;
address oleg =0x5f77b7F905913431957E800BfbDF5a9DB1B911C7;
address fund =0x0Ecff5AA3F6bEcA65e0c39660b8A410c62d18F05;
address mihail =0xb19f59271B64A2f8240b62Dbd6EEDFF38f6778DD;
address reserv1 =0x8a51B8Bc84272E375D2d46A8b29B1E245F2a9248;
address reserv2 =0x3B820FDabc92d338E3625BbA2F81366df1C417d6;
address reserv3 =0xb3B142e2Edccfb844c83CCcc872cFd8A13505240;
address kostya = 0xC4Eb8BfFBAA3BC5dF11bdFD2e3800ed88EE0e5c7;
address igor = 0xCd25FF018807bd8082E27AD7E12A28964c17159D;
address dasha =0x05D6b898701961452298D09B87f072239D836Cf4;
address alexey =0x6BC2ee50CD8491745fD45Fb3a8E400BEdb2e02df;
address emp1 =0x8bfDedbB38ee8e6354BeffdAC26F0c64bBAB4F1d;
address emp2 =0x4BCce99dD86DC640DCd76510aC7E68be67b44dD9;
address emp3 =0x28C6d5D60A57046778be226c1Fea9def8B7bC067;
address emp4 =0x00D56900f9D2d559A89fAEfe2CfbB464B1368dEe;
address emp5 =0x241B9F4eeC66bE554378b1C9fF93FD4aaC0bD31c;
address emp6 =0x536917d509117ccC26171E21CC51335d0b8022CE;
address emp7 =0xf818199304A658B770eEcb85F2ad891D1B582beB;
address emp8 =0x88Aec59d98b2dBEde71F96a5C8044D5b619955C0;
address emp9 =0x35b3bDb3aC3c1c834fb5e9798a6cB9Db97caF370;
address emp10 =0x9CA083D10fC4944F22654829Ac2E9702Ecce204F;
address emp11 =0xBfD84a9641849B07271919AD2ad5F2453F4BF06c;
address emp12 =0x7Ff40441F748229A004bc15e70Fccf3c82A51874;
address emp13 =0xE7B45875d2380113eC3F76E7B7a44549C368E523;
address emp14 =0xB46C56C97664152F77B26c5D0b8B5f1CB642A84E;
address emp15 =0x897a133c4f01aEf11c58fd9Ec0c7932552a39C9f;
address emp16 =0xd9537D3cf1a2624FA309c0AA65ac9eaAE350ef1D;
address emp17 =0x4E4c22151f47D2C236Ac9Ec5D4fC2B46c58b34dE;
function FoundersContract(address _token) public {
token = ROBOToken(_token);
balances_freez_one[muhtov] = 6840000 * 1 ether;
balances_freez_one[scherbakov] = 6840000 * 1 ether;
balances_freez_one[sattarova] = 320000 * 1 ether;
balances_freez_one[roma_kiev] = 900000 * 1 ether;
balances_freez_one[iliya] = 540000 * 1 ether;
balances_freez_one[oleg] = 900000 * 1 ether;
balances_freez_one[fund] = 180000 * 1 ether;
balances_freez_one[mihail] =900000 * 1 ether;
balances_freez_one[reserv1] =180000 * 1 ether;
balances_freez_one[reserv2] =180000 * 1 ether;
balances_freez_one[reserv3] =180000 * 1 ether;
balances_freez_one[kostya] = 250000 * 1 ether;
balances_freez_one[igor] = 100000 * 1 ether;
balances_freez_one[dasha] = 75000 * 1 ether;
balances_freez_one[alexey] = 75000 * 1 ether;
balances_freez_one[emp1] = 75000 * 1 ether;
balances_freez_one[emp2] = 75000 * 1 ether;
balances_freez_one[emp3] = 75000 * 1 ether;
balances_freez_one[emp4] = 75000 * 1 ether;
balances_freez_one[emp5] = 100000 * 1 ether;
balances_freez_one[emp6] = 100000 * 1 ether;
balances_freez_one[emp7] = 100000 * 1 ether;
balances_freez_one[emp8] = 100000 * 1 ether;
balances_freez_one[emp9] = 100000 * 1 ether;
balances_freez_one[emp10] = 100000 * 1 ether;
balances_freez_one[emp11] = 100000 * 1 ether;
balances_freez_one[emp12] = 50000 * 1 ether;
balances_freez_one[emp13] = 50000 * 1 ether;
balances_freez_one[emp14] = 50000 * 1 ether;
balances_freez_one[emp15] = 50000 * 1 ether;
balances_freez_one[emp16] = 50000 * 1 ether;
balances_freez_one[emp17] = 50000 * 1 ether;
balances_freez_two[muhtov] = balances_freez_one[muhtov];
balances_freez_two[scherbakov] = balances_freez_one[scherbakov];
balances_freez_two[sattarova] = balances_freez_one[sattarova];
balances_freez_two[roma_kiev] = balances_freez_one[roma_kiev];
balances_freez_two[iliya] = balances_freez_one[iliya];
balances_freez_two[oleg] = balances_freez_one[oleg];
balances_freez_two[fund] = balances_freez_one[fund];
balances_freez_two[mihail] = balances_freez_one[mihail];
balances_freez_two[reserv1] = balances_freez_one[reserv1];
balances_freez_two[reserv2] = balances_freez_one[reserv2];
balances_freez_two[reserv3] = balances_freez_one[reserv3];
balances_freez_two[kostya] = balances_freez_one[kostya];
balances_freez_two[igor] = balances_freez_one[igor];
balances_freez_two[dasha] = balances_freez_one[dasha];
balances_freez_two[alexey] = balances_freez_one[alexey];
balances_freez_two[emp1] = balances_freez_one[emp1];
balances_freez_two[emp2] = balances_freez_one[emp2];
balances_freez_two[emp3] = balances_freez_one[emp3];
balances_freez_two[emp4] = balances_freez_one[emp4];
balances_freez_two[emp5] = balances_freez_one[emp5];
balances_freez_two[emp6] = balances_freez_one[emp6];
balances_freez_two[emp7] = balances_freez_one[emp7];
balances_freez_two[emp8] = balances_freez_one[emp8];
balances_freez_two[emp9] = balances_freez_one[emp9];
balances_freez_two[emp10] = balances_freez_one[emp10];
balances_freez_two[emp11] = balances_freez_one[emp11];
balances_freez_two[emp12] = balances_freez_one[emp12];
balances_freez_two[emp13] = balances_freez_one[emp13];
balances_freez_two[emp14] = balances_freez_one[emp14];
balances_freez_two[emp15] = balances_freez_one[emp15];
balances_freez_two[emp16] = balances_freez_one[emp16];
balances_freez_two[emp17] = balances_freez_one[emp17];
} | 0 |
function KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = 10;
bonusInPhase2 = 5;
minimumContribution = 5e17;
maximumContribution = 150e18;
ratePerWei = 100e18;
token = TokenInterface(_tokenAddress);
LongTermFoundationBudgetAccumulated = 0;
LegalContingencyFundsAccumulated = 0;
MarketingAndCommunityOutreachAccumulated = 0;
CashReserveFundAccumulated = 0;
OperationalExpensesAccumulated = 0;
SoftwareProductDevelopmentAccumulated = 0;
FoundersTeamAndAdvisorsAccumulated = 0;
LongTermFoundationBudgetPercentage = 15;
LegalContingencyFundsPercentage = 10;
MarketingAndCommunityOutreachPercentage = 10;
CashReserveFundPercentage = 20;
OperationalExpensesPercentage = 10;
SoftwareProductDevelopmentPercentage = 15;
FoundersTeamAndAdvisorsPercentage = 20;
} | 0 |
function removeMany(address[] _wallets) public onlyOwner {
for (uint i = 0; i < _wallets.length; i++) {
remove(_wallets[i]);
}
} | 0 |
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _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 authorized_setCardPerkText(uint256 _cardId, string _perkText) external requireAuthorizedLogicContract {
cardIdToPerkText[_cardId] = _perkText;
} | 0 |
modifier cannotMint() {
require(mintingFinished);
_;
} | 0 |
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, 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;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
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 burn(uint value) external returns (bool);
function isCustodian(address addr) external view returns (bool);
function isMerchant(address addr) external view returns (bool);
function getWBTC() external view returns (ERC20);
}
contract Factory is OwnableContract {
enum RequestStatus {PENDING, CANCELED, APPROVED, REJECTED}
struct Request {
address requester;
uint amount;
string btcDepositAddress;
string btcTxid;
uint nonce;
uint timestamp;
RequestStatus status;
} | 0 |
function buyToken(uint256 _tokenId) public
payable
{
Meme storage meme = memeData[_tokenId];
uint256 price = meme.price;
address oldOwner = meme.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 devCut = price.mul(2).div(100);
developerCut = developerCut.add(devCut);
uint256 creatorCut = price.mul(2).div(100);
creatorBalances[meme.creator] = creatorBalances[meme.creator].add(creatorCut);
uint256 transferAmount = price.sub(creatorCut + devCut);
transferToken(oldOwner, newOwner, _tokenId);
emit Purchase(_tokenId, newOwner, oldOwner, price);
meme.price = getNextPrice(price);
safeTransfer(oldOwner, transferAmount);
if (excess > 0) {
newOwner.transfer(excess);
}
if (address(this).balance > endingBalance + creatorCut + devCut) submissionPool += transferAmount;
endingBalance = address(this).balance;
} | 0 |
function SpaceRegistry() {
spaces.length = START_INDEX;
} | 1 |
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferHash(address(this), tokenOwner, to, tokens, fee, nonce);
} | 0 |
function ResumeICO() external onlyOwner
{
stopped = false;
} | 0 |
function tokensPerWei(uint _amountWei) public view returns (uint256) {
if (5 ether <= _amountWei && _amountWei < 10 ether) return tokensPerWei10;
if (_amountWei < 20 ether) return tokensPerWei15;
if (20 ether <= _amountWei) return tokensPerWei20;
return defaultTokensPerWei;
} | 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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
} | 0 |
function acceptContribution(address addr) external onlyOwner hasKYCInfo(addr) {
require(amountAttempted[addr] >= minContribution);
require(amountContributed[addr].add(amountAttempted[addr]) <= maxContribution);
uint256 amount = amountAttempted[addr];
amountAttempted[addr] = 0;
amountContributed[addr] = amountContributed[addr].add(amount);
amountRaised = amountRaised.add(amount);
amountRemaining = amountRemaining.add(amount);
emit ContributionIncrease(now, amountRaised);
emit ContributionAccepted(addr, amount, amountContributed[addr]);
} | 1 |
function timeLockAdvisor(address _target) public onlySuperAdmins validateAddress(_target) {
require(timelockedAccounts[_target] == 0);
timelockedAccounts[_target] = ADVISOR_LOCKUP_END;
emit LockedFunds(_target, ADVISOR_LOCKUP_END);
} | 0 |
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract NXX is ERC223, Pausable {
using SafeMath for uint256;
using ContractLib for address;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
} | 0 |
function setAsset(address addr) onlyOwnerUnlocked setter {
assetAddress = addr;
} | 0 |
function toString(address x) internal pure returns (string) {
bytes memory b = new bytes(20);
for (uint i = 0; i < 20; i++)
b[i] = byte(uint8(uint(x) / (2**(8*(19 - i)))));
return string(b);
} | 0 |
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
} | 0 |
function balanceOf(address _owner) public view returns (uint256) {
ReleaseType _type = _accountType[_owner];
uint256 balance = _totalBalance[_owner].sub(_spentBalance[_owner]);
if (_owner == owner) {
return balance;
}
uint256 elapsed = now - reference_time;
if (elapsed < 0) {
return 0;
}
if (elapsed >= 21 * 30 minutes) {
return balance;
}
if (_type == ReleaseType.Public) {
return balance;
} else if (_type == ReleaseType.Private1) {
if (elapsed < 3 * 30 minutes) {
return 0;
} else if (elapsed < 6 * 30 minutes) {
return balance / 6;
} else if (elapsed < 9 * 30 minutes) {
return balance * 2 / 6;
} else if (elapsed < 12 * 30 minutes) {
return balance * 3 / 6;
} else if (elapsed < 15 * 30 minutes) {
return balance * 4 / 6;
} else if (elapsed < 18 * 30 minutes) {
return balance * 5 / 6;
} else {
return balance;
}
} else if (_type == ReleaseType.Private23) {
if (elapsed < 6 * 30 minutes) {
return 0;
} else if (elapsed < 9 * 30 minutes) {
return balance / 4;
} else if (elapsed < 12 * 30 minutes) {
return balance * 2 / 4;
} else if (elapsed < 15 * 30 minutes) {
return balance * 3 / 4;
} else {
return balance;
}
} else if (_type == ReleaseType.Foundation) {
if (elapsed < 3 * 30 minutes) {
return 0;
} else if (elapsed < 6 * 30 minutes) {
return balance * 3 / 20;
} else if (elapsed < 9 * 30 minutes) {
return balance * 6 / 20;
} else if (elapsed < 12 * 30 minutes) {
return balance * 9 / 20;
} else if (elapsed < 15 * 30 minutes) {
return balance * 12 / 20;
} else if (elapsed < 18 * 30 minutes) {
return balance * 15 / 20;
} else if (elapsed < 21 * 30 minutes) {
return balance * 18 / 20;
} else {
return balance;
}
} else if (_type == ReleaseType.Ecosystem) {
if (elapsed < 3 * 30 minutes) {
return balance * 5 / 30;
} else if (elapsed < 6 * 30 minutes) {
return balance * 10 / 30;
} else if (elapsed < 9 * 30 minutes) {
return balance * 15 / 30;
} else if (elapsed < 12 * 30 minutes) {
return balance * 18 / 30;
} else if (elapsed < 15 * 30 minutes) {
return balance * 21 / 30;
} else if (elapsed < 18 * 30 minutes) {
return balance * 24 / 30;
} else if (elapsed < 21 * 30 minutes) {
return balance * 27 / 30;
} else {
return balance;
}
} else if (_type == ReleaseType.Team) {
if (elapsed < 12 * 30 minutes) {
return 0;
} else if (elapsed < 15 * 30 minutes) {
return balance / 4;
} else if (elapsed < 18 * 30 minutes) {
return balance * 2 / 4;
} else if (elapsed < 21 * 30 minutes) {
return balance * 3 / 4;
} else {
return balance;
}
} else if (_type == ReleaseType.Airdrop) {
if (elapsed < 3 * 30 minutes) {
return balance / 2;
} else {
return balance;
}
} else if (_type == ReleaseType.Contributor) {
if (elapsed < 12 * 30 minutes) {
return 0;
} else if (elapsed < 15 * 30 minutes) {
return balance / 4;
} else if (elapsed < 18 * 30 minutes) {
return balance * 2 / 4;
} else if (elapsed < 21 * 30 minutes) {
return balance * 3 / 4;
} else {
return balance;
}
}
return 0;
} | 0 |
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
contract ERC721Interface {
function ownerOf(uint256 assetId) public view returns (address);
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
} | 0 |
function PrivateSaleExchangeRate(uint256 _rate) public {
require(_rate > 0);
rate = _rate;
timestamp = now;
} | 0 |
function halt() external onlyOwner {
halted = true;
Halted(true);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
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 setMintFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
mintFee.prop = _value;
emit SetFee("mint", "proportional", _value);
return true;
} | 0 |
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 assignTokens(address _to, uint256 _value) external onlyOwner {
token.transferFromIco(_to, _value);
tokensSold = tokensSold.add(_value);
} | 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];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
}
msg.sender.transfer(msg.value);
}
if (!dungeonRunEnded) {
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
}
} | 0 |
function withdrawal(Token token, address to, uint value) returns (bool) {
require(msg.sender == owner);
require(block.timestamp >= lock);
require(to != address(0));
return token.transfer(to, value);
} | 1 |
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 DebitCoinToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6);
DebitCoinTokenGenesis(address(this));
} | 0 |
function CrowdSale_Halt() external onlyOwner atStage(Stages.ICO) {
stopped = true;
stage = Stages.PAUSED;
} | 0 |
function fundPos() public view returns (uint) {
for(uint i = 0; i < MAX_FUND_SIZE; ++i)
{
if(openingTimeArray[i] <= now && now <= closingTimeArray[i])
{
return i;
}
}
require(false);
} | 0 |
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SafeMath {
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function isTokenOwner(address _owner) constant returns (bool) {
return (ownedToken[_owner] != 0x0 && tokens[ownedToken[_owner]].owner == _owner);
} | 0 |
function withdraw(uint withdrawEther_) public onlyOwner {
msg.sender.transfer(withdrawEther_);
} | 0 |
function unlockTokens() external {
address contributor = msg.sender;
if (holderList[contributor].isActive && !holderList[contributor].withdrawed) {
if (now >= holderList[contributor].holdPeriodTimestamp) {
if ( OppToken.transfer( msg.sender, holderList[contributor].tokens ) ) {
TokensTransfered(contributor, holderList[contributor].tokens);
tokenWithdrawHold += holderList[contributor].tokens;
holderList[contributor].withdrawed = true;
holderWithdrawIndex++;
}
} else {
revert();
}
} else {
revert();
}
} | 1 |
function start_POSTICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.POSTICO;
stopped = false;
maxCap_POSTICO = 20000000 * 10 **18;
balances[address(this)] = maxCap_POSTICO;
postico_startdate = now;
postico_enddate = now + 90 days;
_price_tokn = 5;
emit Transfer(0, address(this), maxCap_POSTICO);
} | 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,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function cancelPayment(uint txnId) private {
Payment memory txn = openPayments[txnId];
txn.paymentCloseTime = now;
txn.state = PaymentState.CANCELLED;
delete openPayments[txnId];
if (txn.token == address(0)) {
tokens[address(0)][txn.sender] = SafeMath.sub(
tokens[address(0)][txn.sender],
txn.sendAmount
);
txn.sender.transfer(txn.sendAmount);
} else {
withdrawToken(txn.token, txn.sender, txn.sender, txn.sendAmount);
}
emit PaymentClosed(
txnId,
txn.holdTime,
txn.paymentOpenTime,
txn.paymentCloseTime,
txn.token,
txn.sendAmount,
txn.sender,
txn.recipient,
txn.codeHash,
uint(txn.state)
);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
bool result = _transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value);
return result;
} | 0 |
function retrieveTokens(uint _value) onlyOwner {
require(_value > 0);
if (now <= 1537876800)
revert();
tokenLocked = token(0xC2eAF62D3DB7c960d8Bb5D2D6a800Dd817C8E596);
tokenLocked.transfer(owner, _value);
} | 1 |
function determineBonus(uint tokens) internal view returns (uint256 bonus)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
if (timeElapsedInDays <8)
{
bonus = tokens.mul(bonusInPreSalePhase1);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
else if (timeElapsedInDays >=8 && timeElapsedInDays <16)
{
bonus = tokens.mul(bonusInPreSalePhase2);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
else if (timeElapsedInDays >=16 && timeElapsedInDays <46)
{
bonus = tokens.mul(bonusInPublicSalePhase1);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
else if (timeElapsedInDays >=46 && timeElapsedInDays <57)
{
bonus = tokens.mul(bonusInPublicSalePhase2);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
else if (timeElapsedInDays >=57 && timeElapsedInDays <63)
{
bonus = tokens.mul(bonusInPublicSalePhase3);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
else
{
bonus = 0;
}
} | 0 |
function balanceOf(address who) view public 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) view public 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 SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function addCastle(address _trainer, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3, uint32 _brickNumber) onlyModerators external returns(uint32 currentCastleId){
currentCastleId = trainerCastle[_trainer];
if (currentCastleId > 0)
return currentCastleId;
totalCastle += 1;
currentCastleId = totalCastle;
CastleData storage castle = castleData[currentCastleId];
castle.name = _name;
castle.owner = _trainer;
castle.monsters[0] = _a1;
castle.monsters[1] = _a2;
castle.monsters[2] = _a3;
castle.monsters[3] = _s1;
castle.monsters[4] = _s2;
castle.monsters[5] = _s3;
castle.brickNumber = _brickNumber;
castle.createTime = now;
castle.index = ++activeCastleList.length;
activeCastleList[castle.index-1] = currentCastleId;
trainerCastle[_trainer] = currentCastleId;
} | 1 |
function openTrading() external onlyOwner {
tradingOpen = true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) public returns (bool) {
bytes memory empty;
require(_value > 0 && _allowance[_from][msg.sender] >= _value && Balances(balancesContract()).get(_from) >= _value);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value);
if(msg.sender != _to && isContract(_to)) {
Balances(balancesContract()).transfer(_from, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(_from, _value, empty);
} else {
Balances(balancesContract()).transfer(_from, _to, _value);
}
Transfer(_from, _to, _value);
Transfer(_from, _to, _value, empty);
return true;
} | 0 |
function getTokenBalance () constant noEther returns (uint256 tokens) {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) return 0;
return account.getTokenBalance();
} | 0 |
function resume() external onlyOwner ifPaused {
paused = false;
} | 0 |
constructor() public
{
name = "LINIXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.