function
string | label
int64 |
|---|---|
function upgradeFrom(address _from, uint256 _value) public {}
}
contract UpgradeableToken is MintableAndPausableToken {
address public upgradeMaster;
bool private upgradesAllowed;
TokenUpgrader public tokenUpgrader;
uint public totalUpgraded;
enum UpgradeState { Unknown, NotAllowed, Waiting, ReadyToUpgrade, Upgrading }
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event TokenUpgraderIsSet(address _newToken);
modifier onlyUpgradeMaster {
require(msg.sender == upgradeMaster);
_;
} | 0 |
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
return SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 345600);
} | 0 |
function StopICO() external onlyOwner {
stopped = true;
stage = Stages.PAUSED;
} | 0 |
modifier addressNotRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor == address(0));
_;
} | 0 |
function saleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
pbIssuedSale = pbIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
} | 0 |
function refundSubmission(address _refundee, uint256 _amount) external onlyAdmin() {
submissionPool = submissionPool.sub(_amount);
_refundee.transfer(_amount);
endingBalance = address(this).balance;
} | 0 |
function changeOperator(address _newOperator) public onlyOperator returns (bool) {
operator = _newOperator;
return true;
} | 0 |
function ecrecoverFromSig(Data storage , bytes32 hash, bytes sig) public pure returns (address recoveredAddress) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) return address(0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) return address(0);
return ecrecover(hash, v, r, s);
} | 0 |
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
} | 0 |
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
burnAmount = communityDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(communityDevelopmentWallet, burnAmount);
burnAmount = reserveSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(reserveWallet, burnAmount);
burnAmount = bountySupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(bountyWallet, burnAmount);
burnAmount = teamSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(teamWallet, burnAmount);
_burn(crowdsaleWallet, crowdsaleBalance);
} | 0 |
function hasEnded() public view returns (bool) {
return now > endTime;
} | 0 |
function __redeemAmount(address investor) internal view returns (uint amount) {
uint allowance = token.allowance(investor, this) / k;
uint balance = balances[investor];
return balance < allowance ? balance : allowance;
} | 0 |
modifier onlyUpgradeMaster() {
require(msg.sender == upgradeMaster);
_;
} | 0 |
function getCurrentContextAddress()
internal
view
returns (address);
}
contract MWrapperFunctions is
IWrapperFunctions
{
function fillOrKillOrderInternal(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
internal
returns (LibFillResults.FillResults memory fillResults);
}
contract Ownable is
IOwnable
{
address public owner;
constructor ()
public
{
owner = msg.sender;
} | 0 |
modifier whenPaused() {
require(paused);
_;
} | 0 |
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 |
function setaddrFWD(address _value) public onlyOwner{
addrFWD=_value;
} | 0 |
function unlock() external {
if (now < unlockedAt) throw;
if (tokensCreated == 0)
tokensCreated = obg.balanceOf(this);
var allocation = allocations[msg.sender];
allocations[msg.sender] = 0;
var toTransfer = tokensCreated * allocation / totalAllocations;
if (!obg.transfer(msg.sender, toTransfer)) throw;
} | 0 |
function random(uint64 upper) public returns (uint64 randomNumber) {
_seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
return _seed % upper;
} | 1 |
function startTournament() onlyOwner nonReentrant external {
require(participants.length == maxParticipantCount);
_firstRoundFight();
_secondRoundWinnersFight();
_secondRoundLosersFight();
_finalRoundWinnersFight();
_finalRoundLosersFight();
uint winnerRewards = tournamentRewards * winPercent / 100;
uint loserRewards = tournamentRewards * losePercent / 100;
uint addToJackpot = tournamentRewards - winnerRewards - loserRewards;
address winner = participants[finalWinner].player;
address loser = participants[finalLoser].player;
winner.transfer(winnerRewards);
loser.transfer(loserRewards);
tournamentJackpot += addToJackpot;
playerToWinCounts[winner]++;
for (uint i = 0; i < participants.length; i++) {
address participant = participants[i].player;
if (participant != winner && playerToWinCounts[participant] != 0) {
playerToWinCounts[participant] = 0;
}
}
uint jackpotRewards;
uint winCount = playerToWinCounts[winner];
if (winCount == jackpotWinCount) {
playerToWinCounts[winner] = 0;
jackpotRewards = tournamentJackpot * jackpotWinPercent / 100;
tournamentJackpot -= jackpotRewards;
winner.transfer(jackpotRewards);
}
tournamentRewards = 0;
previousParticipants = participants;
participants.length = 0;
nextTournamentRound++;
TournamentFinished(now, nextTournamentRound - 1, winner, loser, winnerRewards, loserRewards, winCount, jackpotRewards);
} | 1 |
function isContractPermanent(string _name) view public returns (bool) {
return contracts[_name].isPermanent;
} | 0 |
function withdrawCommunityPart(address _to) public onlyManager() {
require(now > nextWithdrawDayCommunity);
uint _value;
if (withdrawedCoummunityCounter == 0) {
_value = communityReservation / 2;
} else if (withdrawedCoummunityCounter == 1) {
_value = communityReservation * 3 / 10;
} else if (withdrawedCoummunityCounter == 2 || withdrawedCoummunityCounter == 3) {
_value = communityReservation / 10;
} else {
return;
}
balances[_to] = balances[_to].add(_value);
withdrawedCoummunityCounter += 1;
nextWithdrawDayCommunity += 365 days;
totalSupply = totalSupply.add(_value);
emit Transfer(address(this), _to, _value);
} | 0 |
function currentWindow() public constant returns (uint) {
return windowAt(block.timestamp);
} | 1 |
modifier onlyActiveAuction() {
require(isActiveAuction(), "Auction not active");
_;
} | 0 |
function hasEnded() public view returns (bool) {
return now > endTime;
} | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable) public
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
if(!_mintable) {
mintingFinished = true;
require(totalSupply != 0);
}
} | 0 |
function getNextPrice(bytes32 democHash) external view returns (uint);
function noteBallotDeployed(bytes32 democHash) external;
function upgradeMe(address newSC) external;
}
contract safeSend {
bool private txMutex3847834;
function doSafeSend(address toAddr, uint amount) internal {
doSafeSendWData(toAddr, "", amount);
} | 0 |
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
} | 0 |
function max64(uint64 a, uint64 b)
internal
pure
returns (uint256)
{
return a >= b ? a : b;
} | 0 |
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
} | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByHero;
if (now > monster.creationTime + monsterFleeTime) {
damageByMonster = currentLevel + monsterStrength;
} else {
if (currentLevel >= 2) {
damageByMonster = _getRandomNumber(currentLevel / 2);
}
}
if (damageByMonster >= _heroCurrentHealth) {
heroIdToHealth[_heroId] = 0;
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
if (addToJackpot > 0) {
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
heroIdToRefundedFee[_heroId] += addToJackpot;
}
assert(addToJackpot <= entranceFee);
} else {
heroIdToHealth[_heroId] -= damageByMonster;
if (now > monster.creationTime + monsterFleeTime) {
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
damageByHero = (_heroStrength * 1e9 + heroPower * 1e9 / (10 * (1 + _getRandomNumber(5)))) / tx.gasprice;
bool isMonsterDefeated = damageByHero >= monster.health;
if (isMonsterDefeated) {
uint rewards;
uint8 newLevel = currentLevel + 1;
heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
if (currentLevel == checkpointLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == breakevenLevel) {
rewards = entranceFee / 2;
heroIdToRefundedFee[_heroId] += rewards;
entranceFeePool -= rewards;
} else if (currentLevel == jackpotLevel) {
rewards = jackpot / 2;
jackpot -= rewards;
}
msg.sender.transfer(rewards);
} else {
monster.health -= uint8(damageByHero);
}
}
LogAttack(now, msg.sender, _heroId, currentLevel, damageByHero, damageByMonster, isMonsterDefeated, rewards);
} | 0 |
function initialize() public {
require(address(token) == 0);
token = ERC20(msg.sender);
} | 1 |
function timeunlockAccount(address target) public onlyOwner {
timelockAccounts[target] = now;
emit TimeLockFunds(target, now);
} | 0 |
function receiveTokens(uint256 tokens) {
DaoAccount sender = DaoAccount(msg.sender);
if (!AbstractDaoChallenge(daoChallenge).isMember(sender, sender.getOwnerAddress())) throw;
if (tokens > sender.getTokenBalance()) throw;
if (tokenBalance + tokens < tokenBalance) throw;
tokenBalance += tokens;
} | 0 |
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function weiAllowedToReceive(uint weiAmount, address customer) internal constant returns (uint weiAllowed);
function calculatePrice(uint weiAmount, address customer) internal constant returns (uint tokenAmount);
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner notFinished {
require(receiver != address(0));
uint tokenAmount = fullTokens.mul(10**uint(token.decimals()));
require(tokenAmount != 0);
uint weiAmount = weiPrice.mul(tokenAmount);
updateInvestorFunds(tokenAmount, weiAmount, receiver , 0);
} | 0 |
function closeStageTwo() public onlyOwner afterStageOneClosed {
stageTwoClosed = true;
} | 0 |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
} | 0 |
function forwardFunds() internal {
owner.transfer(msg.value);
} | 0 |
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
constructor ()
public
{
EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
keccak256(bytes(EIP712_DOMAIN_NAME)),
keccak256(bytes(EIP712_DOMAIN_VERSION)),
bytes32(address(this))
));
} | 0 |
function symbol() public constant returns (string) {
return symbol;
} | 0 |
function finishMinting() external onlyMinter returns (bool) {
mintingFinished = true;
MintingFinished();
return true;
} | 0 |
function getUpgradeState() public view returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(tokenUpgrader) == address(0)) return UpgradeState.Waiting;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else if (totalUpgraded > 0) return UpgradeState.Upgrading;
return UpgradeState.Unknown;
} | 0 |
function allowance(address owner, address spender) public constant 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 LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint constant public lockPeriod1 = 2 years;
uint constant public lockPeriod2 = 24 weeks;
uint constant public lockPeriodForBuyers = 12 weeks;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
bool public isActivated = false;
mapping (address => bool) public whitelistedBeforeActivation;
mapping (address => bool) public isPresaleBuyer;
address public saleAddress;
address public founder1Address;
address public founder2Address;
uint public icoEndTime;
uint public icoStartTime;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
function VinToken(
address _founder1Address,
address _founder2Address,
uint _icoStartTime,
uint _icoEndTime
) public
{
require(_founder1Address != 0x0);
require(_founder2Address != 0x0);
require(_icoEndTime > _icoStartTime);
founder1Address = _founder1Address;
founder2Address = _founder2Address;
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
balances[owner] = totalSupply;
whitelistedBeforeActivation[owner] = true;
} | 0 |
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) onlyPayloadSize(4 * 32) public returns (bool success) {
if(isContract(_to)) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
require(receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
} | 0 |
function getBalance() view public onlyOwner returns (uint256)
{
return address(this).balance;
} | 0 |
function setPauseMaster(address _pauseMaster) onlyOwner external returns (bool success) {
require(_pauseMaster != address(0));
pauseMaster = _pauseMaster;
return true;
} | 0 |
function sub(uint256 a, uint256 b) internal pure
returns (uint256)
{
assert(b <= a);
return a - b;
} | 0 |
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
} | 0 |
function USD(uint _id) constant returns (uint256);
}
contract TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function ChineseCookies() {
bakeCookie("A friend asks only for your time not your money.");
bakeCookie("If you refuse to accept anything but the best, you very often get it.");
bakeCookie("A smile is your passport into the hearts of others.");
bakeCookie("A good way to keep healthy is to eat more Chinese food.");
bakeCookie("Your high-minded principles spell success.");
bakeCookie("Hard work pays off in the future, laziness pays off now.");
bakeCookie("Change can hurt, but it leads a path to something better.");
bakeCookie("Enjoy the good luck a companion brings you.");
bakeCookie("People are naturally attracted to you.");
bakeCookie("A chance meeting opens new doors to success and friendship.");
bakeCookie("You learn from your mistakes... You will learn a lot today.");
} | 0 |
function approve(address _spender, uint256 _amount)public returns (bool success) {
require(!lockstatus);
require( _spender != 0x0);
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= _balances[msg.sender]);
_balances[msg.sender] = _balances[msg.sender].sub(_value);
_balances[_to] = _balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function PreIco(uint256 _initialSupply, uint256 initialValue, address initialUpdater, uint256 end) {
initialSupply = _initialSupply;
remainingSupply = initialSupply;
tokenValue = initialValue;
updater = initialUpdater;
startBlock = block.number;
endTime = end;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockAdvisors3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x309F0716701f346F2aE84ec9a45ce7E69E747f18;
uint constant UNLOCK_DATE = 1548547199;
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
} | 0 |
function transfer(address _to, uint _value) canTransfer(msg.sender) public returns (bool) {
return super.transfer(_to, _value);
} | 0 |
function distributePresaleTokens(address _buyer, uint tokens) external onlyOwner whenNotPaused {
require(_buyer != address(0));
require(tokens > 0 && tokens <= limitPresale);
require(tokensDistributedPresale < limitPresale);
require(tokensDistributedPresale.add(tokens) < limitPresale);
tokensDistributedPresale = tokensDistributedPresale.add(tokens);
balances[_buyer] = balances[_buyer].add(tokens);
} | 0 |
function voteYes(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(time() <= proposal.startTime.add(OPEN_VOTE_PERIOD), "Governance::voteYes: Proposal is no longer accepting yes votes");
uint proposalEndTime = proposal.startTime.add(TOTAL_VOTE_PERIOD);
if (proposalEndTime > withdrawTimes[msg.sender]) withdrawTimes[msg.sender] = proposalEndTime;
uint weight = deposits[msg.sender].sub(yesVotes[proposalId][msg.sender]);
proposal.yesCount = proposal.yesCount.add(weight);
yesVotes[proposalId][msg.sender] = deposits[msg.sender];
emit Vote(proposalId, msg.sender, true, weight);
} | 0 |
function start_ICO2(uint256 price_tokn_ico2) public onlyOwner atStage(Stages.ICO1)
{
require(price_tokn_ico2 !=0);
require(now > ico1_enddate || balances[address(this)] == 0);
stage = Stages.ICO2;
stopped = false;
_price_tokn_ICO2 = price_tokn_ico2;
maxCap_ICO2 = 264000000 * 10 **18;
balances[address(this)] = (balances[address(this)]).add(maxCap_ICO2) ;
ico2_startdate = now;
ico2_enddate = now + 30 days;
Transfer(0, address(this), balances[address(this)]);
} | 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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function random(uint64 upper) private returns (uint64 randomNumber) {
_seed = uint64(keccak256(keccak256(block.blockhash(block.number), _seed), now));
return _seed % upper;
} | 1 |
function Crowdsale() public {
owner = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
startTime = now;
endTime = 1521187200;
rate = 5000000000000000;
wallet = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
token = DragonToken(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
tokenReserve = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
} | 0 |
modifier isActivated() {
require(activated_ == true, "it's not ready yet");
_;
} | 0 |
modifier beforeEndTime() {
require(now < endTime);
_;
} | 0 |
function addFreezer(address freezer) auth public {
FreezerAuthority(authority).addFreezer(freezer);
} | 0 |
function update(uint256 newTotalSupply, uint256 reservedTokensNextDay) external onlyUpdater {
totalSupply = newTotalSupply;
uint256 daysSupply = newTotalSupply.sub(tokenContract.totalSupply());
statsByDay.push(Day(daysSupply, 0, reservedTokensNextDay, 0));
Update(newTotalSupply, reservedTokensNextDay);
} | 0 |
function finalize() public {
require(!isFinalized);
finalization();
emit Finalized();
isFinalized = true;
} | 0 |
modifier isNotTimeLockedFrom( address _from, address _to) {
require( whitelistedTransferer[_to] || ( now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]));
_;
} | 0 |
function assignTokens(address beneficiary, uint256 amount) private returns(uint256 lockedFor){
lockedFor = now + 45 days;
balances[beneficiary] = balances[beneficiary].add(amount);
releaseTime[beneficiary] = lockedFor;
} | 0 |
function isWhitelisted(address _wallet) public view returns (bool) {
return whitelist[_wallet].whitelisted;
} | 0 |
function getKebabsSincelastKebab(address adr) public view returns(uint256)
{
uint256 secondsPassed=min(KEBABER_TO_MAKE_1KEBAB,SafeMath.sub(now,lastKebab[adr]));
return SafeMath.mul(secondsPassed,workingKebaber[adr]);
} | 0 |
function claimVestedTokens(address _recipient) external {
uint256 yearsVested;
uint256 amountVested;
(yearsVested, amountVested) = calculateGrantClaim(_recipient);
require(amountVested > 0, "amountVested is 0");
Grant storage tokenGrant = tokenGrants[_recipient];
tokenGrant.yearsClaimed = yearsVested;
tokenGrant.totalClaimed = tokenGrant.totalClaimed.add(amountVested);
require(token.transfer(_recipient, amountVested), "no tokens");
emit GrantTokensClaimed(_recipient, amountVested);
} | 0 |
function releaseBonus() public {
uint256 releaseTokens = 0;
if(block.timestamp > (startingTimestamp.add(phase1Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase1[msg.sender]);
lockupPhase1[msg.sender] = 0;
}
if(block.timestamp > (startingTimestamp.add(phase2Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase2[msg.sender]);
lockupPhase2[msg.sender] = 0;
}
if(block.timestamp > (startingTimestamp.add(phase3Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase3[msg.sender]);
lockupPhase3[msg.sender] = 0;
}
if(block.timestamp > (startingTimestamp.add(phase4Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase4[msg.sender]);
lockupPhase4[msg.sender] = 0;
}
totalLockedBonus = totalLockedBonus.sub(releaseTokens);
token.transfer(msg.sender, releaseTokens);
} | 0 |
constructor() public {
term = 86400 - 600;
} | 0 |
function deauthorize(address _trustee_to_remove) returns (bool success) {
authorized[msg.sender][_trustee_to_remove] = false;
Deauthorization(msg.sender, _trustee_to_remove);
return true;
} | 0 |
function close() onlyOwner public
{
selfdestruct(msg.sender);
} | 0 |
function transfer(uint id, address newOwner, string newData)
validID(id) isOwnerOf(id) tradingIsEnabled returns(bool)
{
plots[id].owner = newOwner;
if (bytes(newData).length != 0) {
plots[id].metadata = newData;
}
Transfer(msg.sender, newOwner, id);
addPlot(newOwner, id);
removePlot(msg.sender, id);
return true;
} | 0 |
function unlockAccount(address tokenOwner) public {
return data.unlockAccount(tokenOwner);
} | 0 |
function delWhiteList(address _address) onlyAdmin external {
require(whiteList[_address]);
whiteList[_address] = false;
emit DelWhiteList(_address);
} | 0 |
function transferFrom(address from, address to, uint256 value) external returns (bool) {
require(to != address(0));
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
_balances[from] = _balances[from].sub(value);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
return true;
} | 0 |
function issueTokenWithVesting_Team(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Team >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_Team) ) < time ) && ( vestingRelease_Team[_time] > 0 ) );
uint tokens = vestingRelease_Team[_time];
require(maxSupply_Team >= issueToken_Team.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Team[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Team = issueToken_Team.add(tokens);
emit Issue_team(_to, tokens);
} | 0 |
function blockTime() constant returns (uint32) {
return uint32(block.timestamp);
} | 1 |
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public 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 |
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).approve(msg.sender, _spender, _amount)) throw;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
} | 0 |
function withdrawEther(address traderAddr, address payable withdrawalAddr, uint amount) external
onlyActive()
onlyApprovedExchange(traderAddr) {
deductBalance(0, traderAddr, amount);
resetEmergencyRelease(traderAddr);
emit Withdrawal(0, traderAddr, withdrawalAddr, amount);
withdrawalAddr.transfer(amount);
} | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 |
function auctionExpired() public view returns (bool) {
return now > auctionEnd;
} | 1 |
function addMember(address targetMember, string memberName) onlyOwner public {
uint id = memberId[targetMember];
if (id == 0) {
memberId[targetMember] = members.length;
id = members.length++;
}
members[id] = Member({member: targetMember, memberSince: now, name: memberName});
MembershipChanged(targetMember, true);
} | 1 |
function updateTokensToInvestor(address _investorAddress, uint256 _tokenAmount) public returns(bool) {
require(investors[_investorAddress].isInvestor);
Investor storage currentInvestor = investors[_investorAddress];
currentInvestor.tokenAmount = currentInvestor.tokenAmount.add(_tokenAmount);
require(mycroToken.transferFrom(msg.sender, address(this), _tokenAmount));
emit LogUpdatedTokensToInvestor(_investorAddress, _tokenAmount);
return true;
} | 0 |
function issue_Vesting_Team(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Team >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_Team) ) < time ) && ( vestingRelease_Team[_time] > 0 ) );
uint tokens = vestingRelease_Team[_time];
require(maxSupply_Team >= issueToken_Team.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Team[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Team = issueToken_Team.add(tokens);
emit Issue_team(_to, tokens);
} | 0 |
function authCancel(address from) external returns (uint8 status) {
if (!masterKeys[from] || !trustedClients[msg.sender]) {
Unauthorized(from);
return 0;
}
bytes32 call = functionCalling[from];
if (call == bytes32(0)) {
NothingToCancel(from);
return 1;
} else {
AuthCancel(from, from);
functionCalling[from] = bytes32(0);
functionCalls[call] = 0x0;
return 2;
}
} | 0 |
function transferOwnership(address _newowner) external onlyOwner{
uint new_bal = balances[msg.sender];
owner = _newowner;
balances[owner]= new_bal;
balances[msg.sender] = 0;
} | 0 |
function getOwner() returns (address out) {
return owner;
} | 0 |
function authorized_triggerStashedPayoutTransfer(uint256 _cardId) external requireAuthorizedLogicContract {
Card storage card = allCards[_cardId];
address claimerAddress = card.claimer;
require(claimerAddress != address(0));
uint256 stashedPayout = cardIdToStashedPayout[_cardId];
require(stashedPayout > 0);
cardIdToStashedPayout[_cardId] = 0;
totalStashedPayouts -= stashedPayout;
claimerAddress.transfer(stashedPayout);
} | 0 |
function buy()
public
payable
nonReentrant
returns (uint)
{
address investor = msg.sender;
uint256 payment = msg.value;
require(payment >= c_MinInvestment);
require(now < 1507766400);
uint stq = payment.mul(c_STQperETH);
m_token.mint(investor, stq);
m_funds.transfer(payment);
FundTransfer(investor, payment, true);
return stq;
} | 0 |
function transferOwnership(address newOwner) public;
function _transferOwnership(address newOwner) internal onlyOwner {
require(newOwner != address(0), "Ownable: address is zero.");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.