function
string | label
int64 |
|---|---|
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Coin is ERC20, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal c_totalSupply;
mapping(address => uint256) internal c_balances;
mapping(address => mapping(address => uint256)) internal c_approvals;
function init(uint256 token_supply, string token_name, string token_symbol) internal {
c_balances[msg.sender] = token_supply;
c_totalSupply = token_supply;
name = token_name;
symbol = token_symbol;
}
| 0
|
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) view internal {
require(now >= fundingStartTime);
require(now < fundingEndTime);
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
| 0
|
function _vestedAmount(address token) private view returns (uint256) {
uint256 currentBalance = tokenReward.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[token]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration)) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
}
}
| 0
|
constructor(address _oracle, address _depositor, address _beneficiary) public payable Ownable() {
oracle = IOracle(_oracle);
depositor = _depositor;
beneficiary = _beneficiary;
contractExecuted = false;
expiration = now + TO_EXPIRE;
}
| 0
|
function setCrowdsaleCompleted() {
require(msg.sender == crowdsaleContract);
require(crowdsaleCompleted == false);
crowdsaleCompleted = true;
}
| 0
|
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCPreSaleContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 30 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
}
| 0
|
function Escrow() {
owner = msg.sender;
}
| 0
|
function mintable() public view returns (bool) {
return data.mintable;
}
| 0
|
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) view internal {
require(now >= fundingStartTime);
require(now < fundingEndTime);
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
| 0
|
function SocialActivityToken() public
{
owner = msg.sender;
balances[owner] = 350000000 * (uint256(10) ** decimals);
balances[address(this)] = 650000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
}
| 0
|
function KyberContirbutorWhitelist() {}
event ListAddress( address _user, uint _cap, uint _time );
function listAddress( address _user, uint _cap ) onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
}
| 0
|
function transfer(address _to, uint256 _value) public {
if (TransferActive){_transfer(msg.sender, _to, _value);}
}
| 0
|
function DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
}
| 0
|
function GiftToken(address _ico) public {
pause();
setIcoAddress(_ico);
totalSupply_ = initialTotalSupply;
balances[_ico] = balances[_ico].add(initialTotalSupply);
Transfer(address(0), _ico, initialTotalSupply);
}
| 0
|
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
| 1
|
function addComment(string _comment, address _to, bool _aboutBounty, uint _bountyId)
public
{
if (_aboutBounty){
comments.push(Comment(_comment, msg.sender, address(0), _aboutBounty, _bountyId, block.timestamp));
} else {
comments.push(Comment(_comment, msg.sender, _to, _aboutBounty, _bountyId, block.timestamp));
}
CommentAdded(_comment, msg.sender, _to, block.timestamp);
}
| 0
|
function ETH_EURCENT()
public view
returns (uint256)
{
return uint256(100 ether).div(EUR_WEI);
}
| 0
|
function removeVote(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(proposal.result == Result.Pending, "Governance::removeVote: Proposal is already finalized");
require(time() <= proposal.startTime.add(TOTAL_VOTE_PERIOD), "Governance::removeVote: Proposal is no longer in voting period");
proposal.yesCount = proposal.yesCount.sub(yesVotes[proposalId][msg.sender]);
proposal.noCount = proposal.noCount.sub(noVotes[proposalId][msg.sender]);
delete yesVotes[proposalId][msg.sender];
delete noVotes[proposalId][msg.sender];
emit RemoveVote(proposalId, msg.sender);
}
| 0
|
function updatePromoter2(address _address) external onlyOwner {
require(_address != address(0x0));
promoter2 = _address;
}
| 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
|
function pause() public onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
| 0
|
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0
|
function listAddress( address _user, uint _mincap, uint _maxcap ) public onlyOwner {
require(_mincap <= _maxcap);
require(_user != address(0x0));
addressMinCap[_user] = _mincap;
addressMaxCap[_user] = _maxcap;
ListAddress( _user, _mincap, _maxcap, now );
}
| 1
|
function play()
public
payable
validBet
onlyPlayer
{
require(tickets[msg.sender].block_number == 0);
require(ticketIndex.length < 200);
tickets[msg.sender].is_winner = false;
tickets[msg.sender].is_active = true;
tickets[msg.sender].block_number = block.number;
tickets[msg.sender].block_time = block.timestamp;
tickets[msg.sender].num_votes = 0;
ticketIndex.push(msg.sender);
NewPlayerAdded(ticketIndex.length, getPrizeAmount());
}
| 1
|
function _checkAmountForPay(TeamMember memory member) internal pure returns (uint256)
{
if (member.nextWithdrawal == 0)
{
return member.firstTransferValue;
}
return member.eachTransferValue >= member.totalRemainingAmount
? member.totalRemainingAmount
: member.eachTransferValue;
}
| 0
|
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
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 date_check() private returns(bool check_newyears){
is_leap_year();
if((_year <= now) && (now <= (_year + 1209600))){
return true;
}
else{
return false;
}
}
| 0
|
modifier onlyDaoChallenge() {if (daoChallenge != msg.sender) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoAccount (address _owner, address _challengeOwner) noEther {
owner = _owner;
daoChallenge = msg.sender;
tokenBalance = 0;
challengeOwner = _challengeOwner;
}
| 0
|
function successful() public {
require(state == State.Successful);
uint256 remanent = tokenReward.balanceOf(this);
require(tokenReward.transfer(beneficiary,remanent));
beneficiary.transfer(address(this).balance);
emit LogBeneficiaryPaid(creator);
}
| 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);
if (now > monster.creationTime + monsterFleeTime) {
uint damageByMonster = currentLevel + monsterStrength;
if (damageByMonster >= _heroCurrentHealth) {
heroIdToHealth[_heroId] = 0;
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
} else {
heroIdToHealth[_heroId] -= damageByMonster;
currentLevel++;
heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime),
currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth);
monster = heroIdToMonster[_heroId];
}
}
uint damage = _heroStrength * 1e9 / tx.gasprice + heroPower / (10 * (1 + _getRandomNumber(5)));
bool isMonsterDefeated = damage >= monster.health;
uint rewards;
if (isMonsterDefeated) {
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;
jackpot = 0;
}
msg.sender.transfer(rewards);
} else {
monster.health -= uint8(damage);
}
LogAttack(now, msg.sender, _heroId, currentLevel, damage, isMonsterDefeated, rewards);
}
| 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
|
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 transferFrom( address from, address to, uint value) returns (bool ok) {
if( _balances[from] < value ) {
throw;
}
if( _approvals[from][msg.sender] < value ) {
throw;
}
if( !safeToAdd(_balances[to], value) ) {
throw;
}
_approvals[from][msg.sender] -= value;
_balances[from] -= value;
_balances[to] += value;
Transfer( from, to, value );
return true;
}
| 0
|
function newRCAI(bytes32 info_concealed, bytes32 client_full, bytes32 address_full, address declared_for, uint status) public {
emit RCAI(info_concealed, client_full, address_full, msg.sender, declared_for, status, block.timestamp, block.number);
}
| 0
|
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
| 0
|
constructor(ReadableI _makerDAOMedianizer) {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
}
| 0
|
function validate(address currency, uint256 amount) external onlyHotWallet returns (bool) {
assert(approved[currency] >= amount);
approved[currency] -= amount;
return true;
}
| 0
|
function finalizeContruibute()
private
{
stage = Stages.Ended;
totalAmount = 0;
endTime = now;
}
| 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
|
function hodlerTransfer(address _from, uint256 _value) external onlyRole(ROLE_TRANSFER) returns (bool) {
require(_from != address(0));
require(_value > 0);
address _hodler = msg.sender;
balances[_from] = balances[_from].sub(_value);
balances[_hodler] = balances[_hodler].add(_value);
Transfer(_from, _hodler, _value);
return true;
}
| 0
|
function transfersAllowedTo(address _owner) constant returns (bool) {
return (transfersAllowed == true || allowedTransfersTo[_owner] == true);
}
| 0
|
function buyTokens () returns (uint256 tokens) {
tokens = msg.value / tokenPrice;
if (now > tokenIssueDeadline) throw;
if (tokensIssued >= tokensToIssue) throw;
tokensIssued += tokens;
if (tokensIssued > tokensToIssue) throw;
DaoAccount account = accountFor(msg.sender, true);
if (account.buyTokens.value(msg.value)() != tokens) throw;
notifyBuyToken(msg.sender, tokens, msg.value);
return tokens;
}
| 0
|
function finalize() onlyOwner external {
require(!isFinalized);
endTime = now;
isFinalized = true;
emit Finalized();
}
| 0
|
function balanceOf(address _owner) public view returns (uint256) {
ReleaseType _type = _accountType[_owner];
uint256 balance = _totalBalance[_owner].sub(_spentBalance[_owner]);
if (_owner == owner) {
return balance;
}
uint256 elapsed = now - reference_time;
if (elapsed < 0) {
return 0;
}
if (elapsed >= 21 * 30 minutes) {
return balance;
}
if (_type == ReleaseType.Public) {
return balance;
} else if (_type == ReleaseType.Private1) {
if (elapsed < 3 * 30 minutes) {
return 0;
} else if (elapsed < 6 * 30 minutes) {
return balance / 6;
} else if (elapsed < 9 * 30 minutes) {
return balance * 2 / 6;
} else if (elapsed < 12 * 30 minutes) {
return balance * 3 / 6;
} else if (elapsed < 15 * 30 minutes) {
return balance * 4 / 6;
} else if (elapsed < 18 * 30 minutes) {
return balance * 5 / 6;
} else {
return balance;
}
} else if (_type == ReleaseType.Private23) {
if (elapsed < 6 * 30 minutes) {
return 0;
} else if (elapsed < 9 * 30 minutes) {
return balance / 4;
} else if (elapsed < 12 * 30 minutes) {
return balance * 2 / 4;
} else if (elapsed < 15 * 30 minutes) {
return balance * 3 / 4;
} else {
return balance;
}
} else if (_type == ReleaseType.Foundation) {
if (elapsed < 3 * 30 minutes) {
return 0;
} else if (elapsed < 6 * 30 minutes) {
return balance * 3 / 20;
} else if (elapsed < 9 * 30 minutes) {
return balance * 6 / 20;
} else if (elapsed < 12 * 30 minutes) {
return balance * 9 / 20;
} else if (elapsed < 15 * 30 minutes) {
return balance * 12 / 20;
} else if (elapsed < 18 * 30 minutes) {
return balance * 15 / 20;
} else if (elapsed < 21 * 30 minutes) {
return balance * 18 / 20;
} else {
return balance;
}
} else if (_type == ReleaseType.Ecosystem) {
if (elapsed < 3 * 30 minutes) {
return balance * 5 / 30;
} else if (elapsed < 6 * 30 minutes) {
return balance * 10 / 30;
} else if (elapsed < 9 * 30 minutes) {
return balance * 15 / 30;
} else if (elapsed < 12 * 30 minutes) {
return balance * 18 / 30;
} else if (elapsed < 15 * 30 minutes) {
return balance * 21 / 30;
} else if (elapsed < 18 * 30 minutes) {
return balance * 24 / 30;
} else if (elapsed < 21 * 30 minutes) {
return balance * 27 / 30;
} else {
return balance;
}
} else if (_type == ReleaseType.Team) {
if (elapsed < 12 * 30 minutes) {
return 0;
} else if (elapsed < 15 * 30 minutes) {
return balance / 4;
} else if (elapsed < 18 * 30 minutes) {
return balance * 2 / 4;
} else if (elapsed < 21 * 30 minutes) {
return balance * 3 / 4;
} else {
return balance;
}
} else if (_type == ReleaseType.Airdrop) {
if (elapsed < 3 * 30 minutes) {
return balance / 2;
} else {
return balance;
}
} else if (_type == ReleaseType.Contributor) {
if (elapsed < 12 * 30 minutes) {
return 0;
} else if (elapsed < 15 * 30 minutes) {
return balance / 4;
} else if (elapsed < 18 * 30 minutes) {
return balance * 2 / 4;
} else if (elapsed < 21 * 30 minutes) {
return balance * 3 / 4;
} else {
return balance;
}
}
return 0;
}
| 0
|
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 30 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 61 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 91 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 122 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 153 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 183 * day, 1088418885 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 214 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 244 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 275 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 306 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 335 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 366 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 396 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 427 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 457 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 488 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 519 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 549 * day, 1218304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 580 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 610 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 641 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 672 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 700 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 731 * day, 1084971483 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 761 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 792 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 822 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 853 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 884 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 914 * day, 618304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 945 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 975 * day, 25000000 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1096 * day, 593304816 * SCALING_FACTOR);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
| 0
|
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath::mul: Integer overflow");
return c;
}
| 0
|
function getNow() public returns(uint256){
return now;
}
| 1
|
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 revokeTokens(address receiver, uint tokenAmount) onlyBountyAgent {
if (balances[receiver] >= tokenAmount) {
totalSupply = safeSub(totalSupply, tokenAmount);
balances[receiver] = safeSub(balances[receiver], tokenAmount);
}
}
| 0
|
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
| 0
|
constructor(ReadableI _makerDAOMedianizer) public {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
}
| 0
|
function increaseApproval(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0
|
function symbol() public constant returns (string) {
return symbol;
}
| 0
|
constructor() public {
lock = now;
emit SetLock(0, now);
}
| 0
|
function OBGAllocation(address _prospectors_team) internal {
obg = ProspectorsObligationToken(msg.sender);
unlockedAt = now + 1 days;
allocations[_prospectors_team] = 30000;
}
| 0
|
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
| 0
|
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityToken is ERC20
{
using SafeMath for uint256;
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591);
string public constant name = "Social Activity Token";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * (uint256(10) ** decimals);
address public owner;
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 transferTokens(address _to, uint256 _amount) private returns(bool success) {
require( _to != 0x0);
require(balances[address(this)] >= _amount && _amount > 0);
balances[address(this)] = (balances[address(this)]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
Transfer(address(this), _to, _amount);
return true;
}
| 0
|
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
| 0
|
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| 0
|
function TeamAndAdvisorsAllocation(address tokenAddress, uint256 _unlockAt) public {
require(tokenAddress != address(0) && _unlockAt > now);
icnq = ICNQToken(tokenAddress);
unlockedAt = _unlockAt;
}
| 0
|
function withdraw(uint amount) public {
require(time() > withdrawTimes[msg.sender], "Governance::withdraw: Voters with an active proposal cannot withdraw");
deposits[msg.sender] = deposits[msg.sender].sub(amount);
require(token.transfer(msg.sender, amount), "Governance::withdraw: Transfer failed");
}
| 0
|
function transferMinusComissionAltCoin(TokenERC20 _contract, address _to, uint256 _value, uint256 _commission)
private returns(bool)
{
uint256 _totalComission = _commission;
_contract.transfer(_to, _value.sub(_totalComission));
return true;
}
| 0
|
function transfer(uint128 assetAmount, bytes16 lockID, uint32 event_id) onlyIssuer returns (bool success) {
if(matured==false){
uint128 lockAmount;
bytes32 currencyAndBank;
address executingBond;
address lockFrom;
transferBond[lockID].assetAmount = assetAmount;
transferBond[lockID].event_id = event_id;
Escrow escrow = Escrow(escrowContract);
(lockAmount, currencyAndBank, lockFrom, executingBond) = escrow.lockedMoney(lockID);
transferBond[lockID].lockAmount = lockAmount;
transferBond[lockID].currencyAndBank = currencyAndBank;
transferBond[lockID].executingBond = executingBond;
transferBond[lockID].lockFrom = lockFrom;
transferBond[lockID].issuer = issuer;
transferBond[lockID].balancesIssuer = balances[issuer];
transferBond[lockID].first = balances[issuer]>=assetAmount;
transferBond[lockID].second = escrow.executeLock(lockID, issuer)==true;
if(transferBond[lockID].first && transferBond[lockID].second){
balances[lockFrom] += assetAmount;
balances[issuer] -= assetAmount;
TxExecuted(event_id);
return true;
}
}
return false;
}
| 0
|
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| 0
|
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
| 0
|
function withdrawInvestment(uint256 amountToWithdrawInWei)
noEthSent
{
updateBalances();
if (amountToWithdrawInWei>balance[msg.sender]) throw;
uint8 investorID=255;
for (uint8 k = 0; k<setting_maxInvestors; k++)
{
if (investors[k].investor==msg.sender)
{
investorID=k;
break;
}
}
if (investorID==255) throw;
if (investors[investorID].time+setting_lockPeriod>now) throw;
if (balance[msg.sender]-amountToWithdrawInWei>=setting_minInvestment && amountToWithdrawInWei!=0)
{
balance[msg.sender]-=amountToWithdrawInWei;
payroll-=amountToWithdrawInWei;
if (msg.sender.send(amountToWithdrawInWei)==false) throw;
withdraw(msg.sender, amountToWithdrawInWei);
}
else
{
uint256 fullAmount=balance[msg.sender];
payroll-=fullAmount;
balance[msg.sender]=0;
delete investors[investorID];
if (msg.sender.send(fullAmount)==false) throw;
withdraw(msg.sender, fullAmount);
}
updateMaxBet();
}
| 0
|
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
| 0
|
function refund() public payable {
assert(now >= offset + length);
assert(collected < softCap);
address investor = msg.sender;
uint tokens = __redeemAmount(investor);
uint refundValue = tokens * price;
require(tokens > 0);
refunded += refundValue;
tokensRedeemed += tokens;
refunds++;
__redeemTokens(investor, tokens);
investor.transfer(refundValue + msg.value);
RefundIssued(investor, tokens, refundValue);
}
| 0
|
function end_ICO() external onlyOwner
{
stage = Stages.ENDED;
uint256 x = balances[address(this)];
balances[owner] = (balances[owner]).add(balances[address(this)]);
balances[address(this)] = 0;
emit Transfer(address(this), owner , x);
}
| 0
|
function transfer(address _to, uint256 _value) returns (bool success);
function transfer(address _to, bytes32 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, bytes32 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function approve(address _spender, bytes32 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function isTokenOwner(address _owner) constant returns (bool);
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING() constant returns (uint) {
return _END_MINTING;
}
| 0
|
function BlockbidCrowdsale(uint _goal, uint _cap, uint _startTime, uint _endTime, uint _rate, uint _earlyBonus, address _wallet)
Crowdsale(_startTime, _endTime, _rate, _wallet) public {
require(_cap > 0);
require(_goal > 0);
standardrate = _rate;
earlybonus = _earlyBonus;
cap = _cap;
goal = _goal;
}
| 0
|
function setMultisig(address addr) internal {
require(addr != 0);
multisigWallet = addr;
}
| 0
|
function signedApproveCheck(Data storage self, address tokenOwner, address spender, 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 = signedApproveHash(self, tokenOwner, spender, tokens, fee, nonce);
if (tokenOwner == address(0) || tokenOwner != ecrecoverFromSig(keccak256(signingPrefix, hash), sig)) return BTTSTokenInterface.CheckResult.SignerMismatch;
if (self.accountLocked[tokenOwner]) return BTTSTokenInterface.CheckResult.AccountLocked;
if (self.nextNonce[tokenOwner] != nonce) return BTTSTokenInterface.CheckResult.InvalidNonce;
if (self.balances[tokenOwner] < fee) return BTTSTokenInterface.CheckResult.InsufficientTokensForFees;
if (self.balances[feeAccount] + fee < self.balances[feeAccount]) return BTTSTokenInterface.CheckResult.OverflowError;
return BTTSTokenInterface.CheckResult.Success;
}
| 0
|
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 addTeamAndAdvisorsAllocation(address teamOrAdvisorsAddress, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(teamAndAdvisorsAllocations[teamOrAdvisorsAddress] == 0);
teamAndAdvisorsAllocations[teamOrAdvisorsAddress] = allocationValue;
return true;
}
| 0
|
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
}
| 0
|
function withdrawAdvisorsTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[advisorsAllocation][msg.sender] = allowance(advisorsAllocation, msg.sender);
require(transferFrom(advisorsAllocation, _to, _amountWithDecimals));
}
| 0
|
function div(uint a, uint b) internal returns (uint)
{
assert(b > 0);
uint c = a / b;
return c;
}
| 0
|
function tradeStarttime(uint256 _startTime)public onlyOwner{
tradeStartTime=_startTime.add(1 years);
}
| 0
|
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 totalSupply() public view returns (uint256) {
return _totalSupply;
}
| 0
|
function getPayTo() external view returns (address) {
return _getPayTo();
}
| 0
|
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
function _vote(string name, uint value, address voter) private {
require(babyName == 0);
bytes10 name10 = normalizeAndCheckName(bytes(name));
if (leaderboard[name10] != 0) {
uint newVal = leaderboard[name10];
newVal = addToPart(newVal, S_SCORE_POS, S_SCORE_SIZE, value);
newVal = addToPart(newVal, S_VOTES_POS, S_VOTES_SIZE, 1);
_update(name10, newVal);
} else {
uint uni = 0xFFFF;
uni = setPart(uni, S_SCORE_POS, S_SCORE_SIZE, value);
uint uname = uint(name10);
uni = setPart(uni, S_NAME_POS, S_NAME_SIZE, uname);
uni = setPart(uni, S_VOTES_POS, S_VOTES_SIZE, 1);
uni = setPart(uni, S_TIMESTAMP_POS, S_TIMESTAMP_SIZE, block.timestamp);
uni |= 0xFFFF;
_update(name10, uni);
counter += 1;
NewSuggestion(voter, name, counter);
}
voters[voter][name10] += value;
Vote(voter, name, value);
}
| 1
|
function investmentEntryCost() constant returns(bool open_position, bool unlocked_position, uint buyout_amount, uint investLockPeriod)
{
if (openPosition!=255) open_position=true;
if (cheapestUnlockedPosition!=255)
{
unlocked_position=true;
buyout_amount=minCurrentInvest;
}
investLockPeriod=setting_lockPeriod;
return;
}
| 0
|
function resetAction(uint256 hash) internal {
address addr = functionCalls[hash];
functionCalls[hash] = 0x0;
functionCalling[addr] = 0;
}
| 0
|
function setStandard(bytes32 std) onlyOwnerUnlocked setter {
standard = std;
}
| 0
|
function setup (uint256 _fundingStartTime, uint256 _fundingEndTime, address _token) onlyOwner external {
require (isActive == false);
require (isFinalized == false);
require (msg.sender == owner);
require(_fundingStartTime > 0);
require(_fundingEndTime > 0 && _fundingEndTime > _fundingStartTime);
require(_token != address(0));
isFinalized = false;
isActive = true;
ethFundDeposit = owner;
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
token = _token;
}
| 0
|
constructor () public {
owner = msg.sender;
}
| 0
|
function betOnNumber(uint8 numberChosen)
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
if (numberChosen>36) throw;
uint256 betValue= checkBetValue();
gambles.push(Gamble(msg.sender, false, false, BetTypes.number, numberChosen, betValue, block.number, 37));
}
| 0
|
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
| 0
|
function _transfer(address from, address to, uint256 amount) internal {
require(amount <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
if(saleEndTime > block.timestamp)
_amountForSale = _balances[address(this)];
}
| 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 setReservedTokens(uint day, address[] funders, uint256[] reservedTokens) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].reservedTokensPerDay[day] = reservedTokens[i];
}
ReservedTokensSet(day, funders, reservedTokens);
}
| 0
|
function updateFirstActiveGamble() private
{
for (uint k=firstActiveGamble; k<=firstActiveGamble+50; k++)
{
if (k>=gambles.length || !gambles[k].spinned)
{
firstActiveGamble=k;
break;
}
}
}
| 0
|
modifier multisig (bytes32 hash) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
} else if (functionCalling[msg.sender] == 0) {
if (functionCalls[uint256(hash)] == 0x0) {
functionCalls[uint256(hash)] = msg.sender;
functionCalling[msg.sender] = uint256(hash);
AuthInit(msg.sender);
} else {
AuthComplete(functionCalls[uint256(hash)], msg.sender);
resetAction(uint256(hash));
_
}
} else {
AuthPending(msg.sender);
}
}
| 0
|
function blockTime() constant returns(uint32) {
return uint32(block.timestamp);
}
| 1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.