function
string | label
int64 |
|---|---|
function pause() public onlyOwner
{
paused = true;
emit EPause();
}
| 0
|
function listAddress( address _user, uint _cap ) public onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
}
| 1
|
modifier onlyWhenTransferEnabled()
{
if ( now < transferableStartTime ) {
require(msg.sender == fullTokenWallet || msg.sender == owner);
}
_;
}
| 1
|
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 cancelSellOrder(SellOrder order) noEther onlyDaoChallenge {
uint256 tokens = order.tokens();
tokenBalance += tokens;
order.cancel();
}
| 0
|
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract EyeToken is ERC20, Ownable {
using SafeMath for uint256;
struct Frozen {
bool frozen;
uint until;
}
| 0
|
modifier onlyPayloadSize(uint size) {
require(msg.data.length == size + 4);
_;
}
| 0
|
constructor() public {
totalSupply = 1000 * 10 ** uint256(decimals);
name = "AUMKII Token";
symbol = "AUMKII";
balanceOf[owner] = 400 * 10 ** uint256(decimals);
balanceOf[teamOwner] = 600 * 10 ** uint256(decimals);
}
| 0
|
function allowance(address account, address spender) public view returns (uint remaining) {
return allowed[account][spender];
}
| 0
|
function safeMul(uint a, uint b) internal returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
}
| 0
|
function _createAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) internal returns (uint) {
require(ERC721Interface(_token).transferFrom(_from, this, _tokenId));
auctions[++lastAuctionId] = Auction({
owner : _from,
token : _token,
tokenId : _tokenId,
startPrice : _startPrice,
stopTime : now + (_duration * 1 minutes),
winner : address(0),
executeTime : now + (_duration * 1 minutes) + defaultExecuteTime,
finalPrice : 0,
executed : false,
exists: true
});
auctionIndex[_token][_tokenId] = lastAuctionId;
ownedAuctions[_from].push(lastAuctionId);
emit NewAuction(_from, _tokenId, lastAuctionId);
return lastAuctionId;
}
| 0
|
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 14 days;
ico_second = ico_first + 14 days;
ico_third = ico_second + 14 days;
ico_fourth = ico_third + 14 days;
}
| 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) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20 {
using SafeMath for uint;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| 0
|
function safeAdd(uint a, uint b) internal constant returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
| 0
|
function stop() onlyOwner {
stopped = true;
}
| 0
|
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0
|
function transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) {
require( _to != 0x0);
require(_from == address(this));
balances[_from] = (balances[_from]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
if (_from == 0x0)
{
_totalsupply = _totalsupply.add(_amount);
}
Transfer(_from, _to, _amount);
return true;
}
| 0
|
function unhalt() external onlyFundWallet {
halted = false;
}
| 0
|
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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
|
constructor() public payable {
reset();
}
| 0
|
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
| 0
|
function mint(address _to, string _identity) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
if (ownedToken[_to] != 0x0) return false;
bytes32 id = TokenLib.generateId(_identity);
var token = tokens[id];
if (id == token.id()) return false;
token.owner = _to;
token.identity = _identity;
ownedToken[_to] = id;
Mint(_to, id);
numTokens += 1;
return true;
}
| 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
|
function _mint(address account, uint256 value) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| 0
|
function timeLock(address spender, uint256 date) public onlyOwner returns (bool) {
releaseTimes[spender] = date;
return true;
}
| 0
|
function stakeMinimum () external view returns (uint256) {
return _stakeMinimum;
}
| 0
|
function balanceOf(address account) public view returns (uint balance) {
return balances[account];
}
| 0
|
function addApproval(address spender, uint addedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][spender];
allowed[msg.sender][spender] = oldValue.add(addedValue);
Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
| 0
|
function sub(uint256 a, uint256 b) internal pure
returns (uint256)
{
assert(b <= a);
return a - b;
}
| 0
|
function getRate() public view returns (uint256) {
if (now <= preICO.date)
return preICO.rate;
if (now < icoEndOfStageA.date)
return icoStarts.rate;
if (now < icoEndOfStageB.date)
return icoEndOfStageA.rate;
if (now < icoEnds.date)
return icoEndOfStageB.rate;
return icoEnds.rate;
}
| 0
|
function getCurrentDatetime() private constant returns (uint) {
return now;
}
| 1
|
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferHash(tokenOwner, to, tokens, fee, nonce);
}
| 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
|
function changeOwner(address newOwner) public{
require(msg.sender==owner && msg.sender!=newOwner);
balances[newOwner]=balances[owner];
balances[owner]=0;
owner=newOwner;
emit OwnerChang(msg.sender,newOwner,balances[owner]);
}
| 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);
}
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 changeEndTime(uint256 _newTime) onlyOwner external {
require(endTime >= now);
endTime = _newTime;
}
| 0
|
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
Halted(false);
}
| 0
|
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
constructor() public {
uint256 initialSupply = 10000000000;
totalSupply = initialSupply * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
name = "Game Chain";
symbol = "GMI";
}
| 0
|
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
|
constructor(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
function transfer(address to, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
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);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint8 public decimals;
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
function transfer(address _to, uint _value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function mul(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function withdrawEth() public onlyAdmin(2) {
require(totalDistributed >= softCap, "Too early to retrieve funds");
beneficiary.transfer(address(this).balance);
}
| 0
|
function div10(uint256 a, uint8 b) internal returns (uint256 result) {
for (uint8 i = 0; i < b; i++) {
a /= 10;
}
return a;
}
| 0
|
constructor ()
public
{
EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
keccak256(bytes(EIP712_DOMAIN_NAME)),
keccak256(bytes(EIP712_DOMAIN_VERSION)),
bytes32(address(this))
));
}
| 0
|
function pause() onlyOwner whenNotPaused public returns (bool) {
paused = true;
Pause();
return true;
}
| 0
|
function getIdeasSinceLastDeploy(address adr) public view returns(uint256){
uint256 secondsPassed=min(clones_to_create_one_idea, now.sub(lastDeploy[adr]));
return secondsPassed.mul(arrayOfClones[adr]);
}
| 0
|
function doUpgradeInternal(address nextSC) internal {
ptr = nextSC;
}
| 0
|
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 BTCPToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
}
| 1
|
function decimals() public view returns (uint8) {
return data.decimals;
}
| 0
|
function approve(address _spender, uint256 _amount) returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[msg.sender]);
allowance[msg.sender][_spender] = _amount;
activateAccount(msg.sender);
activateAccount(_spender);
activateAllowanceRecord(msg.sender, _spender);
Approval(msg.sender, _spender, _amount);
return true;
}
| 0
|
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
| 0
|
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
| 0
|
constructor() public {
emit SetOwner(owner, msg.sender);
owner = msg.sender;
}
| 0
|
function distinctInvestors() public constant returns(uint){
return investorCount;
}
| 0
|
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
| 0
|
constructor() public {
owner = beneficiary;
totalSupply = INIT_TOTALSUPPLY * 10 ** uint256(decimals);
vestedAmount = 1000000000 * 10 ** uint256(decimals);
uint256 ownerBalances = totalSupply.sub(vestedAmount);
balances[owner] = ownerBalances;
releasedTime = now.add(2*365 days);
emit Transfer(address(0), owner, ownerBalances);
emit TokenVesting(beneficiary, vestedAmount, releasedTime);
}
| 0
|
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
}
| 1
|
function lockedBalance(address addr) public view returns (uint256) {
return _revocable[addr];
}
| 0
|
function BPESOToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
}
| 1
|
function getMemeData (uint256 _tokenId) external view
returns (address _owner, uint256 _price, uint256 _nextPrice, address _creator)
{
Meme memory meme = memeData[_tokenId];
return (meme.owner, meme.price, getNextPrice(meme.price), meme.creator);
}
| 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 allocateTokens(address participant, uint256 amountTokens) private {
require(vestingSet);
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / 570000000;
uint256 developmentAllocation = safeMul(allocationRatio, 380000000) / precision;
uint256 newTokens = safeAdd(amountTokens, developmentAllocation);
require(safeAdd(totalSupply, newTokens) <= tokenCap);
totalSupply = safeAdd(totalSupply, newTokens);
balances[participant] = safeAdd(balances[participant], amountTokens);
balances[vestingContract] = safeAdd(balances[vestingContract], developmentAllocation);
}
| 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 transfer(address _to, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).transfer(msg.sender, _to, _amount)) throw;
Transfer(msg.sender, _to, _amount);
return true;
}
| 0
|
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
}
| 0
|
function ZeusShieldCoin()
{
}
| 0
|
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
| 0
|
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
pragma solidity ^0.4.23;
library SafeMath {
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 transferFrom(address from, address to, uint value) public returns (bool success) {
uint allowance = allowed[from][msg.sender];
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.sender] = allowance.sub(value);
Transfer(from, to, value);
return true;
}
| 0
|
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
}
| 0
|
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
bool hasBalanceAvailable = crowdsaleBalances[msg.sender] < maxPurchase;
return withinPeriod && nonZeroPurchase && withinTokenLimit && minimumPurchase && hasBalanceAvailable;
}
| 0
|
function mintTokens(address holder, uint256 amount) external
{
assert(msg.sender == ico_contract);
assert(now < endDateICO);
_balances[holder] = add(_balances[holder], amount);
_supply = add(_supply, amount);
Transfer(address(0x0), holder, amount);
}
| 1
|
function getCurrent() internal returns (uint256) {
return now;
}
| 1
|
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 disallowTransfers() onlyOwner {
transfersAllowed = false;
}
| 0
|
function potentialProfit(uint256 amount, uint256 chance)
public
view
returns(uint256)
{
return (amount.mul(99) / chance).sub(amount);
}
| 0
|
modifier canBuy(address _address) {
bool found = false;
uint256 length = supportedERC20Token.length;
for (uint256 i = 0; i < length; i++) {
if (supportedERC20Token[i] == _address) {
require(block.timestamp > starttime[_address]);
require(block.timestamp < endtime[_address]);
found = true;
break;
}
}
require (found);
_;
}
| 0
|
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
approved[msg.sender][_spender] = approved[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, approved[msg.sender][_spender]);
return true;
}
| 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 _forwardFunds() internal {
wallet.transfer(msg.value);
}
| 0
|
function getVoterStakes(address voter, uint asOfBlock) public view returns (uint);
}
interface IScoreOracle {
function getSquareWins(uint home, uint away) public view returns (uint numSquareWins, uint totalWins);
function isFinalized() public view returns (bool);
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
| 0
|
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address _owner)public view returns (uint256 balance);
function allowance(address _owner, address _spender)public view returns (uint remaining);
function transferFrom(address _from, address _to, uint _amount)public returns (bool ok);
function approve(address _spender, uint _amount)public returns (bool ok);
function transfer(address _to, uint _amount)public returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint _amount);
event Approval(address indexed _owner, address indexed _spender, uint _amount);
}
contract AdBank is ERC20
{ using SafeMath for uint256;
string public constant symbol = "ADB";
string public constant name = "AdBank";
uint8 public constant decimals = 18;
uint256 _totalSupply = (1000000000) * (10 **18);
address public owner;
bool stopped = true;
uint256 public eth_received;
uint256 startdate;
uint256 enddate;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
}
| 0
|
function _vestedAmount(IERC20 token) private view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[address(token)]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration) || _revoked[address(token)]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
}
}
| 0
|
function enact_withdrawal_greater_equal(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance >= withdrawValue);
balances[fundWallet] = safeAdd(balances[fundWallet], tokens);
participant.transfer(withdrawValue);
Withdraw(participant, tokens, withdrawValue);
}
| 0
|
function StreamityContract() public TokenERC20(130000000, "Streamity", "STM") {}
function () public payable
{
assert(msg.value >= 1 ether / 10);
require(now >= ICO.startDate);
if (now >= ICO.endDate) {
pauseInternal();
emit CrowdSaleFinished(crowdSaleStatus());
}
if (0 != startIcoDate) {
if (now < startIcoDate) {
revert();
} else {
startIcoDate = 0;
}
}
if (paused == false) {
sell(msg.sender, msg.value);
weisRaised = weisRaised.add(msg.value);
}
}
| 0
|
function balanceOf(address _address) public constant returns (uint256 balance) {
return balances[_address];
}
| 0
|
function changeAirLimitCount(uint256 newAirLimitCount) public onlyOwner {
airLimitCount = newAirLimitCount;
}
| 0
|
function activeUnLockGMI(uint64 timeStamp) public isOwer() {
activatedTime = timeStamp;
activated_ = true;
}
| 0
|
function NamCoin(address _fundsWallet) public {
fundsWallet = _fundsWallet;
totalSupply_ = crowdsaleSupply + tokenContractSupply;
balances[fundsWallet] = crowdsaleSupply;
Transfer(0x0, fundsWallet, crowdsaleSupply);
balances[this] = tokenContractSupply;
Transfer(0x0, this, tokenContractSupply);
}
| 0
|
function pow10(uint256 a, uint8 b) internal returns (uint256 result) {
for (uint8 i = 0; i < b; i++) {
a *= 10;
}
return a;
}
| 0
|
constructor() public {
owner = msg.sender;
}
| 0
|
constructor() public {
creationTime = now;
balances[msg.sender] = totalSupply;
}
| 0
|
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0
|
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
}
| 0
|
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract bitqy is owned {
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public decimals;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event FrozenFunds(address target, bool frozen);
function bitqy(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
)
{
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
}
| 0
|
modifier onlyOwner() {
require(msg.sender == owner || msg.sender==admin);
_;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.