function
string | label
int64 |
|---|---|
function setPrice(uint256 _value) public onlyOwner{
tokenPrice=_value;
}
| 0
|
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PitEur is Ownable, ERC20 {
using SafeMath for uint256;
uint8 private _decimals = 18;
uint256 private decimalMultiplier = 10**(uint256(_decimals));
string private _name = "PIT-EUR";
string private _symbol = "PIT-EUR";
uint256 private _totalSupply = 100000000 * decimalMultiplier;
bool public tradable = true;
address public multisig;
function name() constant returns (string) {
return _name;
}
| 0
|
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 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 StandardToken is ERC20
{
using SafeMath for uint;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
bool public constant isToken = true;
modifier onlyPayloadSize(uint size) {
require(msg.data.length == size + 4);
_;
}
| 0
|
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * 2);}
}
| 0
|
function devFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount,4),100);
}
| 0
|
function random(uint64 upper) public returns (uint64 randomNumber) {
_seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
return _seed % upper;
}
| 1
|
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
| 0
|
function MiningRigFarmer() public{
ceoAddress=msg.sender;
}
| 0
|
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
| 0
|
function init(uint _startDate, uint _duration, uint8 _subject) private {
require(!inProgress());
require(_startDate >= now);
require(_subject > 0 && _subject <= 100);
currentVoting += 1;
startDate = _startDate;
endDate = _startDate + _duration;
votesYes = 0;
votesNo = 0;
subject = _subject;
emit InitVoting(_startDate, endDate, subject);
}
| 0
|
function transfer(address _to, uint256 _value) public returns (bool) {
return false;
}
| 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 DungeonRunAlpha is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function totalSupply() view public returns (uint _supply);
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LINIX Token";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
}
| 0
|
function beneficiary() public view returns(address) {
return _beneficiary;
}
| 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 Crowdsale is Ownable {
using SafeMath for uint256;
ERC20 public token;
uint256 private transactionNum;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public discountRate = 3333;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _token) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = ERC20(_token);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
| 0
|
function close() external onlyOwner {
crowdsaleActive = false;
isCrowdsaleClosed = true;
token.transfer(owner, token.balanceOf(address(this)));
emit Close();
}
| 0
|
function finalize() public initialized {
assert(getBlockNumber() >= startBlock);
assert(msg.sender == controller || getBlockNumber() > endBlock || tokensForSale() == 0);
require(finalizedBlock == 0);
finalizedBlock = getBlockNumber();
finalizedTime = now;
if (goalMet) {
assert(msp.generateTokens(
destTokensTeam,
percent(5).mul(totalSupplyCap).div(percent(100))));
assert(msp.generateTokens(
destTokensReferals,
percent(5).mul(totalSupplyCap).div(percent(100))));
assert(msp.generateTokens(
destTokensSit,
sit.totalSupplyAt(initializedBlock)));
}
msp.changeController(mspController);
Finalized();
}
| 1
|
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
| 0
|
function currentTime() public view returns (uint256) {
return now;
}
| 1
|
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
}
| 0
|
function endSale() onlyOwner public
{
require(saleTime == true);
require(maxSaleSupply == tokenIssuedSale);
saleTime = false;
uint nowTime = now;
endSaleTime = nowTime;
teamVestingTime = endSaleTime + teamVestingLockDate;
for(uint i = 0; i < rndVestingTime; i++)
{
rndVestingTimer[i] = endSaleTime + (month * i);
rndVestingBalances[i] = rndVestingSupply;
}
for(uint i = 0; i < advisorVestingTime; i++)
{
advVestingTimer[i] = endSaleTime + (advisorVestingLockDate * i);
advVestingBalances[i] = advisorVestingSupply;
}
emit EndSale(endSaleTime);
}
| 0
|
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseAllowance(spender, subtractedValue);
}
| 0
|
function addInvestment(address _from, uint256 _value) internal {
investments[_from] = investments[_from].add(_value);
}
| 0
|
function destroy(bytes32 _id) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
var tokenToDestroy = tokens[_id];
ownedToken[tokenToDestroy.owner] = 0x0;
tokenToDestroy.identity = '';
tokenToDestroy.owner = 0x0;
Destroy(_id);
numTokens -= 1;
return true;
}
| 0
|
function validPurchase() internal constant returns (bool) {
uint256 current = now;
bool withinPeriod = current >= startTime && current <= endTime;
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase && withinPeriod;
}
| 1
|
function airdrop(address [] _holders,uint256 paySize) external
onlyOwner
{
uint256 count = _holders.length;
assert(paySize.mul(count) <= balanceOf(msg.sender));
for (uint256 i = 0; i < count; i++) {
transfer(_holders [i], paySize);
airdropSupply = airdropSupply.add(paySize);
}
Wasted(owner, airdropSupply, now);
}
| 1
|
function doPurchase() payable {
require(now >= startICO && now < endPostICO);
require(msg.value > 0);
uint sum = msg.value;
uint tokensAmount;
if(now < endICO){
tokensAmount = sum.mul(ETHUSD).div(tokenIcoUsdCentPrice).div(10000000000);
} else {
tokensAmount = sum.mul(ETHUSD).div(tokenPostIcoUsdCentPrice).div(10000000000);
}
if(sum < bonusWeiAmount){
tokensAmount = tokensAmount.mul(100+smallBonusPercent).div(100);
} else{
tokensAmount = tokensAmount.mul(100+bigBonusPercent).div(100);
}
if(tokenBalance() > tokensAmount){
require(token.transfer(msg.sender, tokensAmount));
multisig.transfer(msg.value);
} else {
manager.transfer(msg.value);
Print("Tokens will be released manually", msg.sender);
}
}
| 0
|
function Ownable() public {
owner = msg.sender;
}
| 0
|
constructor() internal {
owner = msg.sender;
startdate = now;
}
| 0
|
function addMinter(address minter) public onlyOwner{
super._addMinter(minter);
}
| 0
|
function validPurchase() internal view returns (bool) {
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase;
}
| 0
|
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 BeefLedger is ERC20, SafeMath
{
string public constant name = "BeefLedger";
string public constant symbol = "BLT";
uint8 public constant decimals = 6;
uint public totalSupply = 888888888 * 10**6 ;
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
address owner;
uint256 pre_date;
uint256 ico_first;
uint256 ico_second;
uint token_supply_forperiod;
bool ico_status = false;
bool stopped = false;
uint256 price_token;
event MESSAGE(string m);
event ADDRESS(address addres, uint balance);
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
| 0
|
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract admined {
mapping(address => uint8) public level;
constructor() internal {
level[msg.sender] = 2;
emit AdminshipUpdated(msg.sender,2);
}
| 0
|
modifier changesToVestingFreezed(address _adr) {
require(vestingMap[_adr].changeFreezed);
_;
}
| 0
|
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'DEBIT Coin Token';
string public symbol = 'DBC';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
function setDefaultExecuteTime(uint _hours) onlyAdmin external {
defaultExecuteTime = _hours * 1 hours;
}
| 0
|
function storeProof(string sha256) {
proofs[sha256] = block.timestamp;
}
| 1
|
modifier allowedPayments(address payer, uint value) {
if (isPreICOPrivateOpened || isPreICOPublicOpened || isICOOpened) {
revert();
}
if (!isPreICOPrivateClosed || !isPreICOPublicClosed || !isICOClosed) {
revert();
}
if (block.timestamp < ICO_START_TIME) {
revert();
}
_;
}
| 1
|
function transfer(address _to, uint256 _value) public
{
_transfer(msg.sender, _to, _value);
}
| 0
|
function withdraw() onlyOwner public {
require(goalReached() || (finished && now > finishedAt + 14 days));
uint256 weiAmount = this.balance;
if (weiAmount > 0) {
wallet.transfer(weiAmount);
Withdrawal(wallet, weiAmount);
}
}
| 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
|
function getFreeCHICKEN() public {
require(initialized);
require(hatcheryCHICKEN[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatcheryCHICKEN[msg.sender] = STARTING_CHICKEN;
}
| 0
|
function setMultisig(address addr) internal {
require(addr != 0);
multisigWallet = addr;
}
| 0
|
function _holdAgeTimestamp(address owner) internal view returns (uint256 holdAgeTimestamp) {
require(_transferIns[owner].amountInVault > 0,
"You haven't sent any tokens to stake, so there is no stake age to return.");
uint256 _lengthOfHoldTimestamp = (block.timestamp - _transferIns[owner].tokenTimestamp);
holdAgeTimestamp = _lengthOfHoldTimestamp;
}
| 0
|
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(a >= b);
return a - b;
}
| 0
|
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
}
| 0
|
function setFundingCap(uint newCap) public onlyOwner notFinished {
weiFundingCap = ceilingStrategy.relaxFundingCap(newCap, weiRaised);
require(weiFundingCap >= minimumFundingGoal);
FundingCapSet(weiFundingCap);
}
| 0
|
function checkBetResult(uint8 result, BetTypes betType) private
{
if (betType==BetTypes.number) checkBetNumber(result);
else if (betType==BetTypes.parity) checkBetParity(result);
else if (betType==BetTypes.color) checkBetColor(result);
else if (betType==BetTypes.lowhigh) checkBetLowhigh(result);
else if (betType==BetTypes.dozen) checkBetDozen(result);
else if (betType==BetTypes.column) checkBetColumn(result);
updateMaxBet();
}
| 0
|
function unlock() external {
if(now < unlockDate) revert();
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) revert();
}
| 1
|
constructor(address bchAddress) public
{
_bchAddress = bchAddress;
}
| 0
|
function isSane(CrowdsaleToken token) public constant returns (bool);
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract GenericCrowdsale is Haltable {
using SafeMath for uint;
CrowdsaleToken public token;
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 = false;
bool public requireCustomerId = false;
mapping (address => uint) public investedAmountOf;
mapping (address => uint) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint8 public ownerTestValue;
enum State{Unknown, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCId);
event Whitelisted(address addr, bool status);
event Finalized();
function GenericCrowdsale(address team_multisig, uint start, uint end, uint min_goal) internal {
setMultisig(team_multisig);
require(start != 0 && end != 0);
require(block.number < start && start < end);
startsAt = start;
endsAt = end;
minimumFundingGoal = min_goal;
}
| 0
|
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
}
| 0
|
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
|
function deposit() payable {
if(msg.value <= 0) throw;
lastDeposit = block.timestamp;
depositsStack[numDeposits] = Deposit(msg.sender, msg.value);
totalDeposited += msg.value;
checkIfReferee(msg.sender);
FundsDeposited(msg.sender, 3, 10, 0, msg.value);
++numDeposits;
addressPositions[msg.sender].push(numDeposits);
if(active) {
dispatchGains();
}
}
| 1
|
function withdrawPrize() public onlyInactiveAuction {
require(msg.sender == winningBidder || isOwner(), "not authorized");
winningBidder.transfer(prize);
address payable o = address(uint160(owner()));
uint256 bids = winningBid.add(losingBid);
lastDonor.transfer(bids);
o.transfer(address(this).balance);
prize = 0;
}
| 0
|
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x * _y;
require(_x == 0 || z / _x == _y);
return z;
}
| 0
|
function hasEnded() public view returns (bool) {
return now > endTime;
}
| 0
|
function isAuthorized(address logger) returns (bool) {
return authorizedLoggers[logger];
}
| 1
|
function getCurrentTimestamp() internal view returns (uint256){
return now;
}
| 1
|
function burn(uint256 value) public onlyOwner {
require(value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(value);
currentTotalSupply = currentTotalSupply.sub(value);
emit Burn(burner, value);
}
| 0
|
function isFinalizeAgent() public constant returns(bool) {
return true;
}
| 0
|
modifier validateAddress( address _addr )
{
require(_addr != address(0x0));
require(_addr != address(this));
_;
}
| 0
|
function ETH_EURCENT()
public view
returns (uint256)
{
return uint256(100 ether).div(EUR_WEI);
}
| 0
|
function setBonus( uint256 _bonusWeiAmount, uint256 _smallBonusPercent, uint256 _bigBonusPercent ) {
require(msg.sender == manager);
bonusWeiAmount = _bonusWeiAmount;
smallBonusPercent = _smallBonusPercent;
bigBonusPercent = _bigBonusPercent;
}
| 0
|
function prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
}
| 1
|
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(authority);
}
| 0
|
function DUBI() public {
totalSupply = 0;
}
| 0
|
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| 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);
Investment(msg.sender, beneficiary, weiAmount);
forwardFunds();
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value)public returns (bool success) {
if (_to == address(0x0)) revert();
if (_value <= 0) revert();
if (balanceOf[_from] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
| 0
|
function getStatusDeal(bytes32 _hashDeal) external view returns (uint8) {
return streamityTransfers[_hashDeal].status;
}
| 0
|
function setContactInformation(string info) onlyOwner public {
contactInformation = info;
}
| 0
|
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xb030dc3457e03e6a5c2e9c428cbd8f104b5282d5)];
uint[1] memory amounts = [uint(250000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
| 0
|
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function withdraw(address _to, uint256 _value) public {
require(_to != address(0));
require(_value > 0);
require(unFreezeStartDate < now, "not unfrozen yet");
require(
(getUnfrozenAmount(msg.sender).sub(withdrawnBalances[msg.sender]))
>= _value
);
withdrawnBalances[msg.sender] = withdrawnBalances[msg.sender].add(_value);
totalBalance = totalBalance.sub(_value);
token.transfer(_to, _value);
}
| 0
|
function totalSupply() constant public returns (uint256) {
return c_totalSupply;
}
| 0
|
constructor() public{
_supply = 319000000*(10**8);
_balances[freezeOwner] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1560927600, unfreezeValue:9570000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1560928200, unfreezeValue:14355000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1560928800, unfreezeValue:14355000*(10**8), freezed: true}));
}
| 0
|
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| 0
|
function buyWithCustomerId(uint128 customerId) public payable {
require(customerId != 0);
investInternal(msg.sender, customerId);
}
| 0
|
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * 5000;
if(now < startTime + 9*24*60* 1 minutes){
tokens += (tokens * 40) / 100;
if(tokensSold>14000000*10**18) throw;
}else if(now < startTime + 16*24*60* 1 minutes){
throw;
}else if(now < startTime + 23*24*60* 1 minutes){
tokens += (tokens * 20) / 100;
}else if(now < startTime + 25*24*60* 1 minutes){
throw;
}
weiRaised = weiRaised.add(weiAmount);
tokenReward.transfer(beneficiary, tokens);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 0
|
modifier canTransfer() {
if(msg.sender != founder) {
require(mintingFinished);
require(now > allowTransferTimestamp);
}
_;
}
| 1
|
function getClaim(address issuer, address subject, bytes32 key) public constant returns(bytes32) {
return registry[issuer][subject][key];
}
| 0
|
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
tokensWeiRaised = tokensWeiRaised.add(_getTokenAmount(_weiAmount));
_updateFundingGoal();
}
| 0
|
function blockTime() constant returns(uint32) {
return uint32(block.timestamp);
}
| 1
|
function vestedAmount() public view returns (uint256) {
uint256 totalBalance = totalTokensLocked[msg.sender];
if (now < cliff) {
return 0;
} else if (now >= start.add(duration)) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
| 0
|
function approve(address _spender, uint _value) public returns (bool success) {
require (_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function startEmergencyRelease() external {
emergencyReleaseSince[msg.sender] = block.timestamp + EMERGENCY_RELEASE_CHALLENGE_PERIOD;
emit StartEmergencyRelease(msg.sender);
}
| 0
|
modifier onlyIssuer() {
if(msg.sender == issuer) _;
}
| 0
|
modifier onlyAdmin(uint8 _level) {
require(level[msg.sender] >= _level, "You dont have rights for this transaction");
_;
}
| 0
|
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIX_Seedblock is Helper, Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint public decimals;
uint constant private zeroAfterDecimal = 10**18;
uint constant public maxSupply = 2625000 * zeroAfterDecimal;
uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal;
uint public issueToken_Total;
uint public issueToken_SeedBlock;
uint public burnTokenAmount;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event Burn(address indexed _from, uint _value);
event Issue_SeedBlock(address indexed _to, uint _tokens);
event TokenUnLock(address indexed _to, uint _tokens);
constructor() public
{
name = "LNXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
}
| 0
|
function transfer(address to, uint value, bytes calldata data) external returns(bool ok);
function buy(address referrerAddress) payable external returns(uint256);
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address customerAddress, bool includeReferralBonus) external view returns(uint256);
function withdraw() external;
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
| 0
|
function pledgeLoyalty(address pledgeTo) public {
ERC20Detailed erc20 = ERC20Detailed(pledgeTo);
string memory tokenName = erc20.name();
require(bytes(tokenName).length > 0, "Name must not be empty");
string memory tokenSymbol = erc20.symbol();
require(bytes(tokenSymbol).length > 0, "Token Symbol must not be empty");
currentPledge = pledgeTo;
emit LoyaltyPledged(pledgeTo, tokenName, tokenSymbol);
}
| 0
|
function setIssuer(address _issuer, uint32 event_id) onlyOwner returns (bool success) {
if(matured==false && issuer==address(0)){
issuer = _issuer;
balances[_issuer] = totalAssetUnits;
TxExecuted(event_id);
return true;
}
return false;
}
| 0
|
function freezeAccount(address target) public onlyOwner {
frozenAccounts[target] = true;
emit FrozenFunds(target, 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 balanceOf(address who) public constant returns(uint256);
function allowance(address owner, address spender) public constant returns(uint);
function transferFrom(address from, address to, uint value) public returns(bool ok);
function approve(address spender, uint value) public returns(bool ok);
function transfer(address to, uint value) public returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BeefLedger is ERC20, SafeMath
{
string public constant name = "BeefLedger";
string public constant symbol = "BLT";
uint8 public constant decimals = 6;
uint public totalSupply = 888888888 * 10**6 ;
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
address owner;
uint256 pre_date;
uint256 ico_first;
uint256 ico_second;
uint token_supply_forperiod;
bool ico_status = false;
bool stopped = false;
uint256 price_token;
event MESSAGE(string m);
event ADDRESS(address addres, uint balance);
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
| 0
|
function BurnableCrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
CrowdsaleToken(_name, _symbol, _initialSupply, _decimals, _mintable) {
}
| 0
|
function transfer(address _to, uint256 _amount)
returns (bool success)
{
if (!registered) return false;
if (_amount <= 0) return false;
if (frozenRules(msg.sender, _amount)) return false;
if (balances[msg.sender] >= _amount
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
| 0
|
function approveCrowdsale(address _crowdsaleAddress) external;
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.