function
string | label
int64 |
|---|---|
function transferOwnershipImmediately(Data storage self, address newOwner) public {
require(msg.sender == self.owner);
OwnershipTransferred(self.owner, newOwner);
self.owner = newOwner;
self.newOwner = address(0);
} | 0 |
constructor(address _teamAdvisorsReserveTokensAddress) public {
require(_teamAdvisorsReserveTokensAddress != address(0));
teamAdvisorsReserveTokensAddress = _teamAdvisorsReserveTokensAddress;
uint256 teamAdvisorsReserveTokens = 1564265000;
createTokens(teamAdvisorsReserveTokens, teamAdvisorsReserveTokensAddress);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function changeOwner (address newOwner) public onlyOwner {
owner = newOwner;
} | 0 |
function endGameInternal() private {
gameOpponent = address(0);
gameTime = 0;
status = 0;
} | 0 |
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract ExtendedERC20 is StandardToken {
function increaseApproval(address _spender, uint256 _addedValue) onlyPayloadSize(2) public returns (bool) {
allowed[msg.sender][_spender] = safeAdd(allowed[msg.sender][_spender], _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
throw;
}
if (agent == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) throw;
if (upgradeAgent.originalSupply() != totalSupply) throw;
UpgradeAgentSet(upgradeAgent);
} | 0 |
function migrateFrom(address _from, uint256 _value);
}
contract ZeusShieldCoin is owned, ERC20Interface {
string public constant standard = 'ERC20';
string public constant name = 'Zeus Shield Coin';
string public constant symbol = 'ZSC';
uint8 public constant decimals = 18;
uint public registrationTime = 0;
bool public registered = false;
uint256 public totalMigrated = 0;
address public migrationAgent = 0;
uint256 totalTokens = 0;
mapping (address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping (address => bool) public frozenAccount;
mapping (address => uint[3]) public frozenTokens;
uint[3] public unlockat;
event Migrate(address _from, address _to, uint256 _value);
function ZeusShieldCoin()
{
} | 0 |
function _prand(uint _modulo) private view returns (uint) {
require((1 < _modulo) && (_modulo <= 10000));
uint seed1 = uint(block.coinbase);
uint seed2 = now;
return uint(keccak256(seed1, seed2)) % _modulo;
} | 1 |
function upgradeMe(address newSC) only_editors() external {
editAllowed[msg.sender] = false;
editAllowed[newSC] = true;
emit SelfUpgrade(msg.sender, newSC);
} | 0 |
function _setAdmin(address a, bool _givePerms) internal {
admins[currAdminEpoch][a] = _givePerms;
if (_givePerms) {
emit AdminAdded(a);
adminLog.push(a);
} else {
emit AdminRemoved(a);
}
} | 0 |
modifier whenNotPaused() {
require(now > pauseEnd);
_;
} | 0 |
function getBonus() constant returns (uint) {
assert(now > start);
assert(now < end);
uint week = (now - start) / period;
uint8 foundBonus = bonuses[week];
if (foundBonus != 0) {
return foundBonus;
} else {
return 5;
}
} | 0 |
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 _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(tokenExchangeRate);
} | 0 |
function kill() isCreator public {
selfdestruct(owner);
} | 1 |
modifier onlySufficientAmount(string poolId, uint256 amount) {
require(amount <= pools[poolId].availableAmount);
_;
} | 0 |
function DXF_Tokens()
{
admin = msg.sender;
startingDateFunding=now;
multisigDXF=0x7a992f486fbc7C03a3f2f862Ad260f158C5c5486;
members.push(Member(0,0,0));
} | 0 |
constructor()
ERC20Burnable() ERC20Pausable() ERC20() Ownable() ERC20Detailed("Pokersoon JQK Token", "JQK", 18)
public {
_mint(msg.sender, 100000000000000000000000000);
nextminttime = now + 14 * 365 days;
} | 0 |
function makeRandomResult(uint256 guessType, uint256 period, uint256 seed, uint256 maxNumber) onlyMaster
public returns (bool) {
require(guessType > 0);
require(period > 0);
require(seed >= 0);
require(maxNumber > 0);
require(results[guessType][period] <= 0);
require(maxNumber <= 1000000);
uint256 random = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
(guessType).add
(period).add
(seed)))) % maxNumber;
results[guessType][period] = random;
return true;
} | 0 |
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function cancelAuction(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].owner, auctions[_auctionId].tokenId));
emit CancelAuction(_auctionId);
} | 0 |
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 activateAccount(address addr) internal {
if (!accountActive[addr]) {
accountActive[addr] = true;
accountIndex.push(addr);
}
} | 0 |
function privateSaleIssue(address _to) onlyOwner public
{
require(tokenIssuedSale == 0);
uint tokens = privateSaleSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
} | 0 |
function refund(address investor) {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function publish(bytes32 hashed_val) {
if (hash_db[hashed_val].publisher != address(0)) {
throw;
}
hash_db[hashed_val].publisher = msg.sender;
hash_db[hashed_val].stake = msg.sender.balance;
hash_db[hashed_val].burned = msg.value;
hash_db[hashed_val].timestamp = now;
} | 1 |
function sendVesting(uint _id) returns(bool) {
require(now >= (vestings[_id].schedule + vestings[_id].paymentInterval * (vestings[_id].sendings + 1)));
require(vestings[_id].ERC20.transfer(vestings[_id].receiver, vestings[_id].amount));
VestingSent(vestings[_id].receiver, vestings[_id].ERC20, vestings[_id].amount, _id, vestings[_id].sendings);
vestings[_id].sendings++;
vestingBalance[vestings[_id].ERC20] -= vestings[_id].amount;
receiverVestings[vestings[_id].receiver][vestings[_id].ERC20] -= vestings[_id].amount;
if (vestings[_id].sendings == vestings[_id].parts) {
delete vestings[_id];
}
return true;
} | 0 |
function mintInternal(address receiver, uint amount) internal {
total_supply = total_supply.add(amount);
balances[receiver] = balances[receiver].add(amount);
Minted(receiver, amount);
Transfer(0, receiver, amount);
} | 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 setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
require(block.timestamp <= PRICE_CHANGE_ENDING_TIME);
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
} | 0 |
function canWithdraw() public view returns (bool) {
return totalWeiReceived >= minCapWei || now > refundDeadlineTime;
} | 0 |
function inProgress() public view returns (bool);
function yes(address _address, uint _votes) public;
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 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 getLockedAmount_investors(address _investor)
public
constant
returns (uint256)
{
uint256 delieveryDate = investors_deliveryDate[_investor];
uint256 lockedAmt = investors_locked[_investor];
if (now <= delieveryDate) {return lockedAmt;}
if (now <= delieveryDate + 90 days) {return lockedAmt;}
return 0;
} | 0 |
function getMyEggs() public view returns(uint256){
return SafeMath.add(claimedEggs[msg.sender], getEggsSinceLastHatch(msg.sender));
} | 0 |
function tokensale(address recipient) public payable {
require(recipient != 0x0);
if (now < pre_endTime) {
ico_stage = STAGE_PRE_ICO;
} else {
ico_stage = STAGE_MAIN_ICO;
}
if ( fundRaised >= _presaleSupply ) {
ico_stage = STAGE_MAIN_ICO;
}
uint256 weiAmount = msg.value;
uint tokens = weiAmount.mul(getPrice());
require(_icoSupply >= tokens);
balances[token_addr] = balances[token_addr].sub(tokens);
balances[recipient] = balances[recipient].add(tokens);
_icoSupply = _icoSupply.sub(tokens);
fundRaised = fundRaised.add(tokens);
TokenPurchase(msg.sender, recipient, weiAmount, tokens);
if ( tokens == 0 ) {
recipient.transfer(msg.value);
} else {
eth_addr.transfer(msg.value);
}
} | 1 |
function assignOwnership(address newOwner) external onlyOwner {
require(newOwner != 0x0, "Address can not be 0x0");
balances[newOwner] = (balances[newOwner]).add(balances[owner]);
balances[owner] = 0;
owner = newOwner;
emit Transfer(msg.sender, newOwner, balances[newOwner]);
} | 0 |
function upgradeFrom(address _from, uint _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
setUpgradeMaster(_upgradeMaster);
} | 0 |
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 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 4;
uint256 public totalSupply;
address public owner;
address public reserve;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
owner = tokenowner;
reserve = tokenreserve;
buyPrice = tokenbuyPrice;
transferactive = tokentransferactive;
shareactive = tokenshareactive;
coinsaleactive = tokencoinsaleactive;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function setOwner(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function buy() payable public {
uint amount = msg.value * buyPrice;
if (coinsaleactive){_transfer(reserve, msg.sender, amount);}
}
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * 2);}
}
function transfer(address _to, uint256 _value) public {
if (transferactive){_transfer(msg.sender, _to, _value);}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
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;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
} | 0 |
function refund(bytes32 _swapID) external onlyOpenSwaps(_swapID) onlyExpirableSwaps(_swapID) {
Swap memory swap = swaps[_swapID];
swapStates[_swapID] = States.EXPIRED;
swap.ethTrader.transfer(swap.value);
emit LogExpire(_swapID);
} | 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 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 signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveCheck(address(this), tokenOwner, spender, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function tokenPrice() returns (uint256);
}
contract DaoAccount
{
address public daoChallenge;
address public challengeOwner;
uint256 tokenBalance;
address owner;
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyOwner() {if (owner != msg.sender) throw; _}
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 calculateExcessBalance() internal whenNotPaused returns(uint256) {
uint256 amountPaid = msg.value;
uint256 differenceWei = 0;
uint256 exceedingBalance = 0;
if(tokensRaised >= limitTier3) {
uint256 addedTokens = tokensRaised.add(amountPaid.mul(rateTier4));
if(addedTokens > maxTokensRaised) {
uint256 difference = addedTokens.sub(maxTokensRaised);
differenceWei = difference.div(rateTier4);
amountPaid = amountPaid.sub(differenceWei);
}
}
uint256 addedBalance = crowdsaleBalances[msg.sender].add(amountPaid);
if(addedBalance <= maxPurchase) {
crowdsaleBalances[msg.sender] = crowdsaleBalances[msg.sender].add(amountPaid);
} else {
exceedingBalance = addedBalance.sub(maxPurchase);
amountPaid = amountPaid.sub(exceedingBalance);
crowdsaleBalances[msg.sender] = crowdsaleBalances[msg.sender].add(amountPaid);
}
if(differenceWei > 0)
msg.sender.transfer(differenceWei);
if(exceedingBalance > 0) {
msg.sender.transfer(exceedingBalance);
}
return amountPaid;
} | 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;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
modifier whenSaleIsOpen() {
require(now >= startTimestamp && now < endTimestamp);
_;
} | 0 |
function random(uint256 upper) public returns (uint256 randomNumber) {
return maxRandom() % upper;
} | 0 |
function safeDiv(uint a, uint b) pure internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint constant public lockPeriod1 = 2 years;
uint constant public lockPeriod2 = 24 weeks;
uint constant public lockPeriodForBuyers = 12 weeks;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
bool public isActivated = false;
mapping (address => bool) public whitelistedBeforeActivation;
mapping (address => bool) public isPresaleBuyer;
address public saleAddress;
address public founder1Address;
address public founder2Address;
uint public icoEndTime;
uint public icoStartTime;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
function VinToken(
address _founder1Address,
address _founder2Address,
uint _icoStartTime,
uint _icoEndTime
) public
{
require(_founder1Address != 0x0);
require(_founder2Address != 0x0);
require(_icoEndTime > _icoStartTime);
founder1Address = _founder1Address;
founder2Address = _founder2Address;
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
balances[owner] = totalSupply;
whitelistedBeforeActivation[owner] = true;
} | 0 |
function 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) public balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
} | 0 |
function 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 TokenTimelock {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function changeAirAmount(uint256 newAirAmount) public onlyOwner {
airAmount = newAirAmount;
} | 0 |
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
} | 0 |
function _transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) private returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 0 |
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
} | 0 |
function checkoutCart(string _firstname) payable returns (uint)
{
if( msg.value < subtotal[msg.sender] ){ revert(); }
for( uint x = 0; x < cart[msg.sender].length; x++ )
{
if( shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].quantity > 0 )
{
NewSandwichTicket( _firstname, msg.sender,
shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].sandwichName,
cart[msg.sender][x].notes );
decrementQuantity( cart[msg.sender][x].sandwichIdNumber );
}
else
{
revert();
}
}
subtotal[msg.sender] = 0;
delete cart[msg.sender];
return now;
} | 1 |
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);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
constructor() internal {
} | 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 transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyIfTransfersAllowed {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
} | 0 |
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
function issue(address to, uint tokencount) public;
}
contract UncursedToken is ERC20 {
string public symbol = "CB";
string public name = "Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
uint public birthBlock;
address public cursedContract = 0x0;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function UncursedToken() public {
birthBlock = block.number;
} | 0 |
function setTreasuryBalance(uint256 amount) onlyOwnerUnlocked {
treasuryBalance = amount;
} | 0 |
function ShrimpFarmer() public{
ceoAddress=msg.sender;
} | 0 |
function Wolk()
{
if ( msg.sender != owner ) throw;
start_block = 3835853;
end_block = 3836353;
balances[owner] = wolkFund;
reservedTokens = 25 * 10**decimals;
allocations[0x564a3f7d98Eb5B1791132F8875fef582d528d5Cf] = 20;
allocations[0x7f512CCFEF05F651A70Fa322Ce27F4ad79b74ffe] = 1;
allocations[0x9D203A36cd61b21B7C8c7Da1d8eeB13f04bb24D9] = 2;
allocations[0x5fcf700654B8062B709a41527FAfCda367daE7b1] = 1;
allocations[0xC28dA4d42866758d0Fc49a5A3948A1f43de491e9] = 1;
CreateWolk(owner, wolkFund);
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function unpause() public whenPaused onlyMaster {
paused = false;
} | 0 |
function revoke() public onlyOwner returns(bool) {
require(revocable);
require(!revoked);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked = true;
token.safeTransfer(owner, refund);
emit Revoked();
return true;
} | 0 |
function airdrop(address to, uint256 animalId) external contractIsActive {
require(now <= airdropEndTimestamp, "airdrop ended");
donateDna(to, animalId, AIRDROP_EFFECTIVENESS);
emit NewAirdrop(to, animalId);
} | 0 |
function approve(address spender, uint256 value) external returns (bool) {
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
} | 0 |
function setApTime(uint _time) onlyOwner public
{
require(tokenLock == true);
require(saleTime == true);
apLock_1 = _time;
apLock_2 = _time.add(month);
apLock_3 = apLock_2.add(month);
} | 0 |
function setLockup_contributors(address _contributor, uint256 _value, uint256 _countdownDate)
public
onlyOwner
{
require(_contributor != address(0));
contributors_locked[_contributor] = _value;
contributors_countdownDate[_contributor] = _countdownDate;
UpdatedLockingState("contributor", _contributor, _value, _countdownDate);
} | 0 |
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoChallenge () {
challengeOwner = msg.sender;
} | 0 |
function timeUntilNextDividendFetching()
external
view
returns(uint256)
{
uint256 difference = now.sub(lastDividendsFetched);
return difference > DIVIDEND_FETCH_TIME ? 0 : DIVIDEND_FETCH_TIME.sub(difference);
} | 0 |
function setpricefactor(uint256 newPricefactor) external onlyOwner
{
priceFactor = newPricefactor;
} | 0 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function getBackToken(uint256 _id) public returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(holderList[_id] == msg.sender);
holderList[_id] = 0x0;
priceList[_id] = 0;
assert(lottery.changeHolder(_id, msg.sender));
TokenBack(_id);
return true;
} | 0 |
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
} | 0 |
function transfer(address _to, uint256 _value)
whenNotPaused limitForOwner public returns (bool success)
{
return super.transfer(_to, _value);
} | 0 |
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function transferInvestorTokens(InvestorToken token, address to, uint256 amount) external onlyRole(ROLE_TRANSFER_INVESTOR_TOKENS) {
token.transferInvestorTokens(to, amount);
TransferredInvestorTokens(msg.sender, token, to, amount);
} | 0 |
function setMaxAuditDuration(uint _days) external onlyOwner {
maxAuditDuration = _days * 1 days;
} | 0 |
function getAuthorizedAddresses()
external
view
returns (address[] memory);
}
contract IAssetProxy is
IAuthorizable
{
function transferFrom(
bytes assetData,
address from,
address to,
uint256 amount
)
external;
function getProxyId()
external
pure
returns (bytes4);
}
contract IValidator {
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes signature
)
external
view
returns (bool isValid);
}
contract IWallet {
function isValidSignature(
bytes32 hash,
bytes signature
)
external
view
returns (bool isValid);
}
contract IExchangeCore {
function cancelOrdersUpTo(uint256 targetOrderEpoch)
external;
function fillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function cancelOrder(LibOrder.Order memory order)
public;
function getOrderInfo(LibOrder.Order memory order)
public
view
returns (LibOrder.OrderInfo memory orderInfo);
}
contract IAssetProxyDispatcher {
function registerAssetProxy(address assetProxy)
external;
function getAssetProxy(bytes4 assetProxyId)
external
view
returns (address);
}
contract IMatchOrders {
function matchOrders(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
bytes memory leftSignature,
bytes memory rightSignature
)
public
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract ISignatureValidator {
function preSign(
bytes32 hash,
address signerAddress,
bytes signature
)
external;
function setSignatureValidatorApproval(
address validatorAddress,
bool approval
)
external;
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes memory signature
)
public
view
returns (bool isValid);
}
contract ITransactions {
function executeTransaction(
uint256 salt,
address signerAddress,
bytes data,
bytes signature
)
external;
}
contract IWrapperFunctions {
function fillOrKillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function fillOrderNoThrow(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function batchFillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrKillOrders(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchFillOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256[] memory takerAssetFillAmounts,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrders(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketSellOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 takerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrders(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function marketBuyOrdersNoThrow(
LibOrder.Order[] memory orders,
uint256 makerAssetFillAmount,
bytes[] memory signatures
)
public
returns (LibFillResults.FillResults memory totalFillResults);
function batchCancelOrders(LibOrder.Order[] memory orders)
public;
function getOrdersInfo(LibOrder.Order[] memory orders)
public
view
returns (LibOrder.OrderInfo[] memory);
}
contract IExchange is
IExchangeCore,
IMatchOrders,
ISignatureValidator,
ITransactions,
IAssetProxyDispatcher,
IWrapperFunctions
{}
contract MExchangeCore is
IExchangeCore
{
event Fill(
address indexed makerAddress,
address indexed feeRecipientAddress,
address takerAddress,
address senderAddress,
uint256 makerAssetFilledAmount,
uint256 takerAssetFilledAmount,
uint256 makerFeePaid,
uint256 takerFeePaid,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event Cancel(
address indexed makerAddress,
address indexed feeRecipientAddress,
address senderAddress,
bytes32 indexed orderHash,
bytes makerAssetData,
bytes takerAssetData
);
event CancelUpTo(
address indexed makerAddress,
address indexed senderAddress,
uint256 orderEpoch
);
function fillOrderInternal(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
internal
returns (LibFillResults.FillResults memory fillResults);
function cancelOrderInternal(LibOrder.Order memory order)
internal;
function updateFilledState(
LibOrder.Order memory order,
address takerAddress,
bytes32 orderHash,
uint256 orderTakerAssetFilledAmount,
LibFillResults.FillResults memory fillResults
)
internal;
function updateCancelledState(
LibOrder.Order memory order,
bytes32 orderHash
)
internal;
function assertFillableOrder(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
address takerAddress,
bytes memory signature
)
internal
view;
function assertValidFill(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
uint256 takerAssetFillAmount,
uint256 takerAssetFilledAmount,
uint256 makerAssetFilledAmount
)
internal
view;
function assertValidCancel(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo
)
internal
view;
function calculateFillResults(
LibOrder.Order memory order,
uint256 takerAssetFilledAmount
)
internal
pure
returns (LibFillResults.FillResults memory fillResults);
}
contract MAssetProxyDispatcher is
IAssetProxyDispatcher
{
event AssetProxyRegistered(
bytes4 id,
address assetProxy
);
function dispatchTransferFrom(
bytes memory assetData,
address from,
address to,
uint256 amount
)
internal;
}
contract MMatchOrders is
IMatchOrders
{
function assertValidMatch(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder
)
internal
pure;
function calculateMatchedFillResults(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
uint256 leftOrderTakerAssetFilledAmount,
uint256 rightOrderTakerAssetFilledAmount
)
internal
pure
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract MSignatureValidator is
ISignatureValidator
{
event SignatureValidatorApproval(
address indexed signerAddress,
address indexed validatorAddress,
bool approved
);
enum SignatureType {
Illegal,
Invalid,
EIP712,
EthSign,
Wallet,
Validator,
PreSigned,
NSignatureTypes
} | 0 |
modifier spendControl(address currency, uint256 amount) {
assert(Oversight(oversightAddress).validate(currency, amount));
_
} | 0 |
function transferFrom(address _from, address _to, uint256 _value)
whenNotPaused limitForOwner public returns (bool success)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
function viewRand() public view returns(uint256) {
return randToAddress[msg.sender];
} | 0 |
function getResult(uint256 guessType, uint256 period)
public view returns (uint256){
require(guessType > 0);
require(period > 0);
require(results[guessType][period] > 0);
return results[guessType][period];
} | 0 |
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using ECRecovery for bytes32;
uint8 constant public STATUS_NO_DEAL = 0x0;
uint8 constant public STATUS_DEAL_WAIT_CONFIRMATION = 0x01;
uint8 constant public STATUS_DEAL_APPROVE = 0x02;
uint8 constant public STATUS_DEAL_RELEASE = 0x03;
TokenERC20 public streamityContractAddress;
uint256 public availableForWithdrawal;
uint32 public requestCancelationTime;
mapping(bytes32 => Deal) public streamityTransfers;
function StreamityEscrow(address streamityContract) public {
require(streamityContract != 0x0);
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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 getUpgradeState() public view returns(UpgradeState) {
if (!canUpgrade()) return UpgradeState.NotAllowed;
else if (address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if (totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
} | 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 transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract PhotochainVesting {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
constructor(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp, "Release time must be in future");
require(_releaseTime < block.timestamp + 3 * 365 days, "Release time must not exceed 3 years");
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 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 authorized_updateSaleInfo(uint256 _cardId, uint256 _sentValue) external requireAuthorizedLogicContract {
cardIdToSaleInfo[_cardId] = SaleInfo(uint128(now), uint128(_sentValue));
} | 0 |
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function AlgoryToken() UpgradeableToken(msg.sender) {
owner = msg.sender;
totalSupply = INITIAL_SUPPLY;
balances[owner] = totalSupply;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.