function
string | label
int64 |
|---|---|
function setLock(uint256 _lock) external onlyOwner {
require(_lock > lock, "Can't set lock to past");
require(_lock - lock <= MAX_LOCK_JUMP, "Max lock jump exceeded");
emit SetLock(lock, _lock);
lock = _lock;
} | 0 |
function determineBonus(uint tokens) internal view returns (uint256 bonus)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
if (timeElapsedInDays <15)
{
bonus = tokens.mul(bonusInPreSalePhase1);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSaleInClosedPreSale);
}
else if (timeElapsedInDays >=15 && timeElapsedInDays <31)
{
bonus = tokens.mul(bonusInPreSalePhase2);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSaleInClosedPreSale);
}
else
{
bonus = 0;
}
} | 0 |
function burnTokens() external onlyCrowdsale whenNotPaused {
uint256 remainingICOToken = limitCrowdsale.sub(tokensDistributedCrowdsale);
if(remainingICOToken > 0 && !remainingTokenBurnt) {
remainingTokenBurnt = true;
limitCrowdsale = limitCrowdsale.sub(remainingICOToken);
totalSupply = totalSupply.sub(remainingICOToken);
}
} | 0 |
function currentRound() public view returns (uint256) {
return now.sub(startTime).div(1 days);
} | 0 |
modifier onlyExchanger() {
require(exchangers[msg.sender]);
_;
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
} | 0 |
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _tokens) public returns(bool resultTransfer);
function transferFrom(address _from, address _to, uint256 _tokens) public returns(bool resultTransfer);
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
using SafeMath for uint256;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
} | 0 |
function approve(address _spender, uint256 _amount) public returns (bool) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function timestamp(bytes32 hash) public returns (bool) {
if (timestamps[hash].timestamp != 0) {
return false;
}
timestamps[hash].timestamp = block.timestamp;
timestamps[hash].sender = msg.sender;
return true;
} | 1 |
function withdraw() public {
assert(creator == msg.sender || beneficiary == msg.sender);
assert(collected >= softCap);
assert(this.balance > 0);
uint value = this.balance;
__beneficiaryTransfer(value);
} | 0 |
modifier hasBeenStopped() {
require(stopped);
_;
} | 0 |
function slice32(bytes b, uint offset) constant returns (bytes32) {
bytes32 out;
for (uint i = 0; i < 32; i++) {
out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
}
return out;
} | 0 |
function claimRefund() notPaused public returns (bool) {
require(!goalReached);
require(hasEnded());
uint contributedAmt = weiContributed[msg.sender];
require(contributedAmt > 0);
weiContributed[msg.sender] = 0;
msg.sender.transfer(contributedAmt);
LogClaimRefund(msg.sender, contributedAmt);
return true;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
} | 0 |
function updateMaritalStatus(string _maritalStatus) public {
require((msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address) && (partner1_voted_update_marriage_status == true)&&(partner2_voted_update_marriage_status == true));
saveContractEvent("Marital status updated", strConcat("Marital status changed from ", maritalStatus , " to ", _maritalStatus));
maritalStatus = _maritalStatus;
partner1_voted_update_marriage_status = false;
partner2_voted_update_marriage_status = false;
} | 0 |
function getLockedAmount_contributors(address _contributor)
public
constant
returns (uint256)
{
uint256 countdownDate = contributors_countdownDate[_contributor];
uint256 lockedAmt = contributors_locked[_contributor];
if (now <= countdownDate + (180 * 1 days)) {return lockedAmt;}
if (now <= countdownDate + (180 * 2 days)) {return lockedAmt.mul(7).div(8);}
if (now <= countdownDate + (180 * 3 days)) {return lockedAmt.mul(6).div(8);}
if (now <= countdownDate + (180 * 4 days)) {return lockedAmt.mul(5).div(8);}
if (now <= countdownDate + (180 * 5 days)) {return lockedAmt.mul(4).div(8);}
if (now <= countdownDate + (180 * 6 days)) {return lockedAmt.mul(3).div(8);}
if (now <= countdownDate + (180 * 7 days)) {return lockedAmt.mul(2).div(8);}
if (now <= countdownDate + (180 * 8 days)) {return lockedAmt.mul(1).div(8);}
return 0;
} | 0 |
function Crowdsale() public {
owner = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
startTime = now;
endTime = 1521187200;
rate = 5000000000000000;
wallet = 0xF615Ac471E066b5ae4BD211CC5044c7a31E89C4e;
token = DragonToken(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
tokenReserve = 0xdd870fa1b7c4700f2bd7f44238821c26f7392148;
} | 0 |
function hasSaleEndTimeCome() public view returns(bool) {
return (block.timestamp > saleEndTime);
} | 0 |
function lock(address _address) public onlyOwner {
lockedAddress[_address] = true;
} | 0 |
modifier emergencyReleasePossible(address trader) {
uint deadline = emergencyReleaseSince[trader];
require (deadline > 0 && block.timestamp > deadline, "Challenge should be active and deadline expired.");
_;
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
uint256 value = msg.value;
uint256 tokens = calculate(value);
require(isValidPurchase(value , tokens));
totalTokenSold = totalTokenSold.add(tokens);
totalEtherRaised = totalEtherRaised.add(value);
etherRaisedPerWallet[msg.sender] = etherRaisedPerWallet[msg.sender].add(value);
token.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, value, tokens, now);
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function lock(address addr, uint256 periodInDays) public {
require(locked[addr] < now && (msg.sender == saleAgent || msg.sender == addr));
locked[addr] = now + periodInDays * 1 days;
} | 0 |
function transfer(address _to, uint _value) public returns (bool)
{
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _to != 0x0, "Receiver can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked");
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (result == BTTSTokenInterface.CheckResult.AccountLocked) {
return "Account locked";
} else if (result == BTTSTokenInterface.CheckResult.SignerMismatch) {
return "Mismatch in signing account";
} else if (result == BTTSTokenInterface.CheckResult.InvalidNonce) {
return "Invalid nonce";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokens) {
return "Insufficient approved tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokensForFees) {
return "Insufficient approved tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokens) {
return "Insufficient tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokensForFees) {
return "Insufficient tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.OverflowError) {
return "Overflow error";
} else {
return "Unknown error";
}
} | 0 |
function isLocked() returns (bool status) {
return locked;
} | 0 |
function burn(uint256 amount) public returns (bool) {
_burn(msg.sender, amount);
return true;
} | 0 |
function initiateMigration(Proxy identity, address newIdManager) public
onlyOlderOwner(identity)
validAddress(newIdManager)
{
migrationInitiated[identity] = now;
migrationNewAddress[identity] = newIdManager;
LogMigrationInitiated(identity, newIdManager, msg.sender);
} | 0 |
function withdrawEarnings()
external
updateDividends
{
uint256 amount = playerVault[msg.sender];
require(amount > 0);
playerVault[msg.sender] = 0;
p3xContract.transfer(msg.sender, amount);
} | 0 |
function isLocked(address _spender) public view returns (bool) {
if (releaseTimes[_spender] == 0 || releaseTimes[_spender] <= block.timestamp) {
return false;
}
return true;
} | 0 |
function hashOrder(bytes details, OrderDetails memory order) internal pure returns (bytes32) {
return keccak256(
abi.encodePacked(
details,
order.settlementID,
order.tokens,
order.price,
order.volume,
order.minimumVolume
)
);
} | 0 |
function transfer( address to, uint value) returns (bool ok) {
if( _balances[msg.sender] < value ) {
throw;
}
if( !safeToAdd(_balances[to], value) ) {
throw;
}
_balances[msg.sender] -= value;
_balances[to] += value;
Transfer( msg.sender, to, value );
return true;
} | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersPromo[promo] != referral){
partner = partnersPromo[promo];
referrals[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].balance += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(amount)))/10000;
p_referral = (amount*ref_percent)/10000;
}
}
} | 1 |
function registerSale(address _tokenFactory, address _congressAddress)
public
onlyOwner
{
if (!registered) {
totalTokens = 6100 * 1000 * 1000 * 10**18;
balances[_tokenFactory] = 3111 * 1000 * 1000 * 10**18;
balances[_congressAddress] = 2074 * 1000 * 1000 * 10**18;
teamAllocation();
registered = true;
registrationTime = now;
unlockat[0] = registrationTime + 6 * 30 days;
unlockat[1] = registrationTime + 12 * 30 days;
unlockat[2] = registrationTime + 24 * 30 days;
}
} | 0 |
function GRO() public {
fundWallet = msg.sender;
whitelist[fundWallet] = true;
previousUpdateTime = currentTime();
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function settle(bytes32 _buyID, bytes32 _sellID) external {
require(orderStatus[_buyID] == OrderStatus.Submitted, "invalid buy status");
require(orderStatus[_sellID] == OrderStatus.Submitted, "invalid sell status");
require(
orderDetails[_buyID].settlementID == RENEX_ATOMIC_SETTLEMENT_ID ||
orderDetails[_buyID].settlementID == RENEX_SETTLEMENT_ID,
"invalid settlement id"
);
require(SettlementUtils.verifyMatchDetails(orderDetails[_buyID], orderDetails[_sellID]), "incompatible orders");
require(orderbookContract.orderMatch(_buyID) == _sellID, "unconfirmed orders");
TokenPair memory tokens = getTokenDetails(orderDetails[_buyID].tokens);
require(tokens.priorityToken.registered, "unregistered priority token");
require(tokens.secondaryToken.registered, "unregistered secondary token");
address buyer = orderbookContract.orderTrader(_buyID);
address seller = orderbookContract.orderTrader(_sellID);
require(buyer != seller, "orders from same trader");
execute(_buyID, _sellID, buyer, seller, tokens);
matchTimestamp[_buyID][_sellID] = now;
orderStatus[_buyID] = OrderStatus.Settled;
orderStatus[_sellID] = OrderStatus.Settled;
} | 0 |
function Ownable() public { owner = msg.sender; }
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 0 |
function motionWaiting(uint motionID)
public
view
returns (bool)
{
return motionStartTime[motionID] + votingPeriod + confirmationPeriod <= now;
} | 0 |
function withdrawTo(address to, uint amount) public payable {
if (isOwner() && isReleasable()) {
uint withdrawMax = deposits[msg.sender];
if (withdrawMax > 0 && amount <= withdrawMax) {
to.transfer(amount);
Withdrawal(amount);
}
}
} | 1 |
function finish() onlyOwner public {
require(!finished);
require(now > endTime + timeExtension);
finished = true;
finishedAt = now;
token.finishMinting();
if (goalReached()) {
token.transferOwnership(owner);
withdraw();
} else {
refunding = true;
Refunding();
}
Finalized();
} | 0 |
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Mintable {
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) private allowed;
function totalSupply() public view returns (uint) {
return total_supply;
} | 0 |
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
} | 0 |
modifier canTransfer(address _sender) {
require(released || transferAgents[_sender]);
_;
} | 0 |
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
} | 0 |
modifier isUserAbleToTransferCheck() {
if(msg.sender == companyReserve){
if(now<isUserAbleToTransferTime){
revert();
}
_;
}else {
_;
}
} | 1 |
function invest() {
if (msg.value<jackpot/2) throw;
lastInvestor = msg.sender;
jackpot += msg.value/2;
lastInvestmentTimestamp = block.timestamp;
} | 1 |
function giveBackOwnership(address _wallet)
public {
token.transferOwnership(_wallet);
} | 0 |
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath::div: Invalid divisor zero");
uint256 c = a / b;
return c;
} | 0 |
function isBuyOrder(bytes32 _orderID) private view returns (bool) {
uint64 tokens = orderDetails[_orderID].tokens;
uint32 firstToken = uint32(tokens >> 32);
uint32 secondaryToken = uint32(tokens);
return (firstToken < secondaryToken);
} | 0 |
function listAddress( address _user, uint _amount ) public onlyOwner {
require(_user != address(0x0));
addressCap[_user] = _amount;
ListAddress( _user, _amount, now );
} | 1 |
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedTransfer(address(this), tokenOwner, to, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
} | 0 |
function calculateTokens(uint value) internal view returns (uint256 tokens)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
uint256 bonus = 0;
if (timeElapsedInDays <15)
{
tokens = value.mul(ratePerWei);
bonus = tokens.mul(bonusInPhase1);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else if (timeElapsedInDays >=15 && timeElapsedInDays <30)
{
tokens = value.mul(ratePerWei);
bonus = tokens.mul(bonusInPhase2);
bonus = bonus.div(100);
tokens = tokens.add(bonus);
require (TOKENS_SOLD.add(tokens) <= maxTokensToSale);
}
else
{
bonus = 0;
}
} | 0 |
function canPegBeIncreased() external view returns(bool) {
return (address(this).balance.mul(etherPeg) <= daiContract.balanceOf(address(this)).div(50) && (now > pegMoveReadyTime));
} | 0 |
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function transfer(address to, uint256 value, bytes data) returns (bool);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInterface is ERC223{
event Mint(address indexed to, uint256 amount);
function changeMinter(address newAddress) returns (bool);
function mint(address _to, uint256 _amount) returns (bool);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
} | 0 |
function unfreeze(uint256 i) public {
require(msg.sender == owner);
require(i>=0 && i<unfreezeTimeMap.length);
require(now >= unfreezeTimeMap[i].unfreezeTime && unfreezeTimeMap[i].freezed);
require(_balances[0x01] >= eachUnfreezeValue);
_balances[0x01] = sub(_balances[0x01], eachUnfreezeValue);
_balances[owner] = add(_balances[owner], eachUnfreezeValue);
freezedValue = sub(freezedValue, eachUnfreezeValue);
unfreezeTimeMap[i].freezed = false;
Transfer(0x01, owner, eachUnfreezeValue);
} | 0 |
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
} | 1 |
function vaultFunds() public onlyOwner {
require(msg.sender == owner);
require(_raised >= tokenCreationMin);
ethFundDeposit.transfer(address(this).balance);
} | 0 |
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract VantaToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
address private creator;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint private constant month = 2592000;
uint constant public maxTotalSupply = 56200000000 * E18;
uint constant public maxSaleSupply = 19670000000 * E18;
uint constant public maxBdevSupply = 8430000000 * E18;
uint constant public maxMktSupply = 8430000000 * E18;
uint constant public maxRndSupply = 8430000000 * E18;
uint constant public maxTeamSupply = 5620000000 * E18;
uint constant public maxReserveSupply = 2810000000 * E18;
uint constant public maxAdvisorSupply = 2810000000 * E18;
uint public totalTokenSupply;
uint public tokenIssuedSale;
uint public apIssuedSale;
uint public bpIssuedSale;
uint public pbIssuedSale;
uint public tokenIssuedBdev;
uint public tokenIssuedMkt;
uint public tokenIssuedRnd;
uint public tokenIssuedTeam;
uint public tokenIssuedReserve;
uint public tokenIssuedAdvisor;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
mapping (address => uint) public ap1;
uint public apLock_1 = 1514818800;
mapping (address => uint) public ap2;
uint public apLock_2 = 1514818800;
mapping (address => uint) public ap3;
uint public apLock_3 = 1514818800;
mapping (address => uint) public bp1;
uint public bpLock_1 = 1514818800;
mapping (address => uint) public bp2;
uint public bpLock_2 = 1514818800;
bool public tokenLock = true;
bool public saleTime = true;
event Burn(address indexed _from, uint _value);
event SaleIssue(address indexed _to, uint _tokens);
event BdevIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RndIssue(address indexed _to, uint _tokens);
event TeamIssue(address indexed _to, uint _tokens);
event ReserveIssue(address indexed _to, uint _tokens);
event AdvisorIssue(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "VANTA Token";
decimals = 18;
symbol = "VNT";
creator = msg.sender;
totalTokenSupply = 0;
tokenIssuedSale = 0;
tokenIssuedBdev = 0;
tokenIssuedMkt = 0;
tokenIssuedRnd = 0;
tokenIssuedTeam = 0;
tokenIssuedReserve = 0;
tokenIssuedAdvisor = 0;
require(maxTotalSupply == maxSaleSupply + maxBdevSupply + maxMktSupply + maxRndSupply + maxTeamSupply + maxReserveSupply + maxAdvisorSupply);
} | 0 |
function getAdminLogN() view external returns (uint) {
return adminLog.length;
} | 0 |
function setRemoteContractAddress (address remoteContractAddress)
external onlyOwner returns (bool success) {
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
success = true;
} | 0 |
function requestAddressChange(address _newRegisteredAddress)
public
vestingScheduleConfirmed(msg.sender)
addressNotRegistered(_newRegisteredAddress)
addressNotNull(_newRegisteredAddress)
{
addressChangeRequests[msg.sender] = _newRegisteredAddress;
emit AddressChangeRequested(msg.sender, _newRegisteredAddress);
} | 0 |
function removeLiquidity(uint256 amount) external onlyManagingWallets {
require(amount <= this.balance);
fundWallet.transfer(amount);
RemoveLiquidity(amount);
} | 0 |
function signedTransferCheck(Data storage self, address tokenContract, address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.NotTransferable;
bytes32 hash = signedTransferHash(self, tokenContract, tokenOwner, to, tokens, fee, nonce);
if (tokenOwner == address(0) || tokenOwner != ecrecoverFromSig(self, keccak256(signingPrefix, hash), sig)) return BTTSTokenInterface.CheckResult.SignerMismatch;
if (self.accountLocked[tokenOwner]) return BTTSTokenInterface.CheckResult.AccountLocked;
if (self.executed[tokenOwner][hash]) return BTTSTokenInterface.CheckResult.AlreadyExecuted;
uint total = safeAdd(tokens, fee);
if (self.balances[tokenOwner] < tokens) return BTTSTokenInterface.CheckResult.InsufficientTokens;
if (self.balances[tokenOwner] < total) return BTTSTokenInterface.CheckResult.InsufficientTokensForFees;
if (self.balances[to] + tokens < self.balances[to]) return BTTSTokenInterface.CheckResult.OverflowError;
if (self.balances[feeAccount] + fee < self.balances[feeAccount]) return BTTSTokenInterface.CheckResult.OverflowError;
return BTTSTokenInterface.CheckResult.Success;
} | 0 |
function deposit() public payable {}
function getToken() public returns(address);
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
} | 0 |
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function invest() public payable {
assert(now >= offset && now < offset + length);
assert(collected + price <= hardCap || hardCap == 0);
require(msg.value >= price);
address investor = msg.sender;
uint tokens = msg.value / price;
uint value = tokens * price;
if (value + collected > hardCap || hardCap == 0) {
value = hardCap - collected;
tokens = value / price;
value = tokens * price;
}
collected += value;
tokensIssued += tokens;
__issueTokens(investor, tokens);
investor.transfer(msg.value - value);
if (collected >= softCap && this.balance >= quantum) {
__beneficiaryTransfer(this.balance);
}
InvestmentAccepted(investor, tokens, value);
} | 0 |
function lockAccount(address account, uint256 unlockTime) onlyOwner public{
require(unlockTime > now);
lockedAccount[account] = unlockTime;
emit LockAccount(account,unlockTime);
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Vesting {
using SafeMath for uint256;
ERC20 public mycroToken;
event LogFreezedTokensToInvestor(address _investorAddress, uint256 _tokenAmount, uint256 _daysToFreeze);
event LogUpdatedTokensToInvestor(address _investorAddress, uint256 _tokenAmount);
event LogWithdraw(address _investorAddress, uint256 _tokenAmount);
constructor(address _token) public {
mycroToken = ERC20(_token);
} | 0 |
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 allowance(address tokenOwner, address spender) public constant returns (uint) {
return allowed[tokenOwner][spender];
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
constructor() internal {
level[0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98] = 2;
emit AdminshipUpdated(0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98, 2);
} | 0 |
function release() public returns(bool) {
uint256 unreleased = releasableAmount();
require(unreleased > 0);
if (releaseTime > 0) {
require(block.timestamp >= releaseTime);
}
released = released.add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
return true;
} | 0 |
function verifyTokens(uint64 _buyTokens, uint64 _sellToken) internal pure returns (bool) {
return ((
uint32(_buyTokens) == uint32(_sellToken >> 32)) && (
uint32(_sellToken) == uint32(_buyTokens >> 32)) && (
uint32(_buyTokens >> 32) <= uint32(_buyTokens))
);
} | 0 |
function isWhitelisted(address funder) external view returns (bool) {
return knownFunders[funder].whitelisted;
} | 0 |
function generateRand() private returns (uint) {
privSeed = (privSeed*3 + 1) / 2;
privSeed = privSeed % 10**9;
uint number = block.number;
uint diff = block.difficulty;
uint time = block.timestamp;
uint gas = block.gaslimit;
uint total = privSeed + number + diff + time + gas;
uint rand = total % 37;
return rand;
} | 1 |
function payFee(bytes32 _serviceName, uint256 _multiplier, address _client) public returns(bool paid) {
require(isValidService(_serviceName));
require(_multiplier != 0);
require(_client != 0);
require(block.timestamp < nextPaymentTime);
return true;
} | 0 |
function setBursar(address _newBursar) external requireGod {
require(_newBursar != address(0));
bursarAddress = _newBursar;
} | 0 |
function _transfer(address _from, address _to, uint _value) internal whenNotPaused {
require(_to != address(0x0));
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
require(!isAccountLocked(_from));
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
} | 0 |
modifier onContractStopped() {
require( halted == true);
_;
} | 0 |
function rndIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require(_time < rndVestingTime);
uint nowTime = now;
require( nowTime > rndVestingTimer[_time] );
uint tokens = rndVestingSupply;
require(tokens == rndVestingBalances[_time]);
require(maxRnDSupply >= tokenIssuedRnD.add(tokens));
balances[_to] = balances[_to].add(tokens);
rndVestingBalances[_time] = 0;
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedRnD = tokenIssuedRnD.add(tokens);
emit RnDIssue(_to, tokens);
} | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_fourth);
stage = Stages.ENDED;
_totalsupply = (_totalsupply).sub(balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
} | 0 |
function startUnlockingPeriod() public onlyOwner {
require (beginUnlockDate == 0);
beginUnlockDate = now;
} | 0 |
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 SATCoin is ERC20
{ using SafeMath for uint256;
string public constant name = "SATCoin";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * 10 ** 8;
address public owner;
uint256 public _price_tokn = 7000 ;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
uint256 public startdate;
uint256 ico_first;
uint256 ico_second;
uint256 ico_third;
uint256 ico_fourth;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 0 |
function balanceOf(address src) public view returns (uint256) {
return _balances[src];
} | 0 |
function getDepositMultiplier()public view returns(uint){
uint percent = getPercent();
uint rate = balances[msg.sender].mul(percent).div(10000);
uint depositMultiplier = now.sub(time[msg.sender]).div(dividendsTime);
return(rate.mul(depositMultiplier));
} | 0 |
function transferTokensFromContract(address _to, uint256 _value) public onlyOwner
{
avaliableSupply = avaliableSupply.sub(_value);
_transfer(this, _to, _value);
} | 0 |
function createOrder(uint256 assetId, uint256 priceInWei, uint256 expiresAt) public whenNotPaused {
address assetOwner = nonFungibleRegistry.ownerOf(assetId);
require(msg.sender == assetOwner);
require(nonFungibleRegistry.isAuthorized(address(this), assetId));
require(priceInWei > 0);
require(expiresAt > now.add(1 minutes));
bytes32 auctionId = keccak256(
block.timestamp,
assetOwner,
assetId,
priceInWei
);
auctionByAssetId[assetId] = Auction({
id: auctionId,
seller: assetOwner,
price: priceInWei,
expiresAt: expiresAt
});
if (publicationFeeInWei > 0) {
require(acceptedToken.transferFrom(
msg.sender,
owner,
publicationFeeInWei
));
}
AuctionCreated(
auctionId,
assetId,
assetOwner,
priceInWei,
expiresAt
);
} | 0 |
function unmintTokens(address hodler, uint amount)
returns (bool ok)
{
require(msg.sender == mintMaster);
require(amount > 0);
require(balances[hodler] >= amount);
balances[hodler] = balances[hodler].safeSub(amount);
totalSupply = totalSupply.safeSub(amount);
LogUnmintTokens(hodler, amount, balances[hodler], totalSupply);
Transfer(hodler, address(0), amount);
return true;
} | 0 |
function returnWei() onlyOwner external {
owner.transfer(this.balance);
} | 0 |
function buy(address referralAddress) external payable {
uint256 tokensToBuy = msg.value / TOKEN_PRICE;
uint256 tokenBalance = chiContract.balanceOf(address(this));
uint256 remainder = msg.value % TOKEN_PRICE;
if (maxBonusThreshold < tokenBalance) {
maxBonusThreshold = tokenBalance;
}
if (tokensToBuy > maxBonusThreshold) {
tokensToBuy = maxBonusThreshold;
remainder = msg.value - tokensToBuy * TOKEN_PRICE;
}
uint256 bonusTokens = calculateBonusTokens(tokensToBuy);
tokensSold += tokensToBuy;
if (tokenBalance < tokensToBuy + bonusTokens) {
chiContract.transfer(msg.sender, tokenBalance);
} else {
chiContract.transfer(msg.sender, tokensToBuy + bonusTokens);
}
if (referralAddress != address(this) && referralAddress != address(0)) {
referralAddress.send(
msg.value * REVENUE_SHARE_PERCENTAGE / 100
);
}
if (remainder > 0) {
msg.sender.transfer(remainder);
}
LogChiPurchase(msg.sender, referralAddress, tokensToBuy, now);
} | 1 |
function Havven(TokenState initialState, address _owner)
ExternStateProxyToken("Havven", "HAV", 1e8 * UNIT, address(this), initialState, _owner)
SelfDestructible(_owner, _owner)
public
{
lastTransferTimestamp[this] = now;
feePeriodStartTime = now;
lastFeePeriodStartTime = now - targetFeePeriodDurationSeconds;
penultimateFeePeriodStartTime = now - 2*targetFeePeriodDurationSeconds;
} | 0 |
modifier isSaleOn() {
require(start <= now && saleOngoing);
_;
} | 1 |
function HoloWhitelist() public {
updater = msg.sender;
} | 0 |
function _transfer(address from, address to, uint256 value) internal {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.