function
string | label
int64 |
|---|---|
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
| 0
|
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract TokenTimelock {
ERC20Basic token;
address beneficiary;
uint releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
function currTime() constant returns (uint) {
if (testing) {
return fakeTime;
} else {
return block.timestamp;
}
}
| 1
|
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
}
| 0
|
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
| 0
|
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
Unpause();
return true;
}
| 0
|
constructor() public { }
function totalSupply() public view returns (uint256) {
return _supply;
}
| 0
|
function allowance(address tokenOwner, address spender) external returns(uint remaining);
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);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract admined {
mapping(address => uint8) public level;
constructor() internal {
level[0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98] = 2;
emit AdminshipUpdated(0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98, 2);
}
| 0
|
function newBitsoAddress(address _newAddress) onlyManager public{
addressManager= _newAddress;
}
| 0
|
function peek() external view returns(bytes32, bool);
function read() external view returns(bytes32);
}
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 thisweek() internal view returns (uint256) {
return now / 1 weeks;
} function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
function transferBalance(address upContract) external onlyControl {
require(upContract != address(0) && upContract.send(this.balance));
}
function () payable public {
uint256 qty = calc(msg.value);
if(qty > 0) {
balances[msg.sender] += qty;
balances[owner] -= qty;
Transfer(owner, msg.sender, qty);
update();
} else revert();
| 1
|
function setFeePercentage(uint8 _percentage) ownerOnly {
feePercentage = _percentage > 100 ? 100 : _percentage;
}
| 0
|
function mistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543658400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543662000, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543668600, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543676400, freezed: true}));
}
| 0
|
function lock(address[] calldata addresses, uint256[] calldata values, uint256[] calldata times) external onlyOwner {
require(!_started);
require(addresses.length == values.length && values.length == times.length);
for (uint256 i = 0; i < addresses.length; i++) {
require(balanceOf(addresses[i]) >= values[i]);
if (!_locked[addresses[i]].locked) {
_locked[addresses[i]].locked = true;
}
_locked[addresses[i]].batches.push(Batch(values[i], block.timestamp + times[i]));
if (_locked[addresses[i]].batches.length > 1) {
assert(
_locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 1].amount
< _locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 2].amount
&&
_locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 1].time
> _locked[addresses[i]].batches[_locked[addresses[i]].batches.length - 2].time
);
}
}
_started = true;
}
| 0
|
function getTotalSupply() constant returns (uint supply) {
return totalAssetUnits;
}
| 0
|
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
}
| 0
|
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
uint256 saleTokens = 600000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
| 0
|
function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
return balanceOf(holder);
}
| 0
|
function addMinter(address minter) public;
function removeMinter(address minter) public;
function cap() public view returns (uint256) {
return _cap;
}
| 0
|
modifier onlyInactiveAuction() {
require(!isActiveAuction(), "Auction not expired");
_;
}
| 0
|
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PitEur is Ownable, ERC20 {
using SafeMath for uint256;
uint8 private _decimals = 18;
uint256 private decimalMultiplier = 10**(uint256(_decimals));
string private _name = "PIT-EUR";
string private _symbol = "PIT-EUR";
uint256 private _totalSupply = 100000000 * decimalMultiplier;
bool public tradable = true;
address public multisig;
function name() constant returns (string) {
return _name;
}
| 0
|
function 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
|
function add(address _owner, uint16 _species, uint8 _subSpecies, uint8 _eyeColor) external onlyCaller {
Creature memory _creature = Creature({
species: _species,
subSpecies: _subSpecies,
eyeColor: _eyeColor,
timestamp: uint64(now)
});
uint256 newCreatureID = creatures.push(_creature) - 1;
transfer(0, _owner, newCreatureID);
CreateCreature(newCreatureID, _owner);
}
| 1
|
function ecrecoverFromSig(Data storage , bytes32 hash, bytes sig) public pure returns (address recoveredAddress) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) return address(0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) return address(0);
return ecrecover(hash, v, r, s);
}
| 0
|
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
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 allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AirSwapExchange {
mapping (bytes32 => bool) public fills;
event Filled(address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
event Canceled(address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
event Failed(uint code, address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
function fill(address makerAddress, uint makerAmount, address makerToken,
address takerAddress, uint takerAmount, address takerToken,
uint256 expiration, uint256 nonce, uint8 v, bytes32 r, bytes32 s) payable {
if (makerAddress == takerAddress) {
msg.sender.transfer(msg.value);
Failed(1,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (expiration < now) {
msg.sender.transfer(msg.value);
Failed(2,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
bytes32 hash = validate(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce, v, r, s);
if (fills[hash]) {
msg.sender.transfer(msg.value);
Failed(3,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (takerToken == address(0x0)) {
if (msg.value == takerAmount) {
fills[hash] = true;
assert(transfer(makerAddress, takerAddress, makerAmount, makerToken));
makerAddress.transfer(msg.value);
Filled(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
} else {
msg.sender.transfer(msg.value);
Failed(4,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
}
} else {
if (msg.value != 0) {
msg.sender.transfer(msg.value);
Failed(5,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (takerAddress == msg.sender) {
fills[hash] = true;
assert(trade(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken));
Filled(
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
} else {
Failed(6,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
}
}
}
| 1
|
function freeze(uint256 _value)public returns (bool success) {
if (balanceOf[msg.sender] < _value) revert();
if (_value <= 0) revert();
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);
emit Freeze(msg.sender, _value);
return true;
}
| 0
|
function setTokenInformation(string _name, string _symbol) public onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
| 0
|
function blacklist(address address_) external onlyOwner {
delete whitelist[address_];
emit ICOBlacklisted(address_);
}
| 0
|
function getNow() internal constant returns (uint256) {
return now;
}
| 1
|
function approve(address spender, uint value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.approve(spender, value);
}
| 0
|
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
| 0
|
function get_balance() public view returns(uint balance){
return bank[msg.sender];
}
| 0
|
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (parentAddress[_to]) {
if (msg.sender==returnChildAddressForParent[_to]) {
if (numRewardsUsed[msg.sender]<maxRewardUnitsAvailable) {
uint256 currDate=block.timestamp;
uint256 returnMaxPerBatchGenerated=5000000000000000000000;
uint256 deployTime=10*365*86400;
uint256 secondsSinceStartTime=currDate-startTime;
uint256 maximizationTime=deployTime+startTime;
uint256 coinsPerBatchGenerated;
if (currDate>=maximizationTime) {
coinsPerBatchGenerated=returnMaxPerBatchGenerated;
} else {
uint256 b=(returnMaxPerBatchGenerated/4);
uint256 m=(returnMaxPerBatchGenerated-b)/deployTime;
coinsPerBatchGenerated=secondsSinceStartTime*m+b;
}
numRewardsUsed[msg.sender]+=1;
balanceOf[msg.sender]+=coinsPerBatchGenerated;
}
}
}
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
| 1
|
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
}
| 0
|
function auditSecret(bytes32 _swapID) external view onlyClosedSwaps(_swapID) returns (bytes32 secretKey) {
Swap memory swap = swaps[_swapID];
return swap.secretKey;
}
| 0
|
function triggerCrossFork(string _btcAddress) isCrossForking public returns(ForkResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
if (crossForkIds[_btcAddress] > 0) {
LogTriggerCrossFork(btcAddressHash, crossForkIds[_btcAddress], ForkResultCode.RECEIVED);
return ForkResultCode.RECEIVED;
}
crossForkCount += 1;
CrossForkData storage crossForkData = crossForkMapping[crossForkCount];
crossForkData.btcAddress = _btcAddress;
crossForkData.receiver = msg.sender;
crossForkData.amount = 0;
crossForkData.createTime = now;
CrossForkDistribution crossfork = CrossForkDistribution(crossForkDistribution);
crossfork.getDistributedAmount(crossForkCount, _btcAddress, msg.sender);
LogTriggerCrossFork(btcAddressHash, crossForkIds[_btcAddress], ForkResultCode.TRIGGERED);
return ForkResultCode.TRIGGERED;
}
| 1
|
function setaddrFWD(address _value) public onlyOwner{
addrFWD=_value;
}
| 0
|
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 subApproval(address spender, uint subtractedValue) public returns (bool success) {
uint oldVal = allowed[msg.sender][spender];
if (subtractedValue > oldVal) {
allowed[msg.sender][spender] = 0;
} else {
allowed[msg.sender][spender] = oldVal.sub(subtractedValue);
}
Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
| 0
|
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
| 0
|
function updateWallet(address _wallet, string _data) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
}
| 0
|
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
| 0
|
function unlock() external {
if(now < unlockDate) throw;
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) throw;
}
| 1
|
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
}
| 1
|
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 authorized_createCard(uint256 _socialNetworkType, uint256 _socialId, address _owner, address _claimer) external requireAuthorizedLogicContract returns (uint256) {
return _createCard(_socialNetworkType, _socialId, _owner, _claimer);
}
| 0
|
function div(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
| 0
|
function transfer(address to, uint256 amount) external returns (bool) {
require(block.timestamp < tokensDestructTime);
require(block.timestamp > saleEndTime);
_transfer(msg.sender, to, amount);
emit Transfer(msg.sender, to, amount);
return true;
}
| 0
|
function mint(address _to, string _identity) returns (bool success);
function destroy(bytes32 _id) returns (bool success);
function addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
function totalSupply() returns (uint supply);
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
|
modifier isOwer() {
require(msg.sender == owner_, "you need owner auth");
_;
}
| 0
|
function min64(uint64 a, uint64 b) internal constant returns (uint64)
{
return a < b ? a : b;
}
| 0
|
function checkBalance(address account) constant returns (uint128 _balance) {
if(matured)
return 0;
return balances[account];
}
| 0
|
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes signature, uint expireTime, uint sequenceId) private returns (address) {
var otherSigner = recoverAddressFromSignature(operationHash, signature);
if (safeMode && !isSigner(toAddress)) {
throw;
}
if (expireTime < block.timestamp) {
throw;
}
tryInsertSequenceId(sequenceId);
if (!isSigner(otherSigner)) {
throw;
}
if (otherSigner == msg.sender) {
throw;
}
return otherSigner;
}
| 1
|
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract migration {
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 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;
}
}
| 1
|
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunAlpha is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
}
| 0
|
function safeTransfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0);
require(_to != address(this));
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(_from, _to, _value);
}
| 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 unlockVestedTokens() external {
Grant storage grant_ = grants[msg.sender];
require(grant_.value != 0);
uint256 vested = calculateVestedTokens(grant_, block.timestamp);
if (vested == 0) {
return;
}
uint256 transferable = vested.sub(grant_.transferred);
if (transferable == 0) {
return;
}
grant_.transferred = grant_.transferred.add(transferable);
totalVesting = totalVesting.sub(transferable);
token.safeTransfer(msg.sender, transferable);
emit TokensUnlocked(msg.sender, transferable);
}
| 0
|
function SmartOToken() public {
balances[msg.sender] = initialSupply;
totalSupply = initialSupply;
}
| 0
|
modifier whenNotPaused() {
if(msg.sender != distributionContract) {
require(!paused);
}
_;
}
| 0
|
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
}
| 0
|
function withdrawCommisionToAddressAltCoin(address _to, uint256 _amount) external onlyOwner {
streamityContractAddress.transfer(_to, _amount);
}
| 0
|
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
| 0
|
modifier vestingScheduleNotConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(!vestingSchedule.isConfirmed);
_;
}
| 0
|
function unown() onlyOwner {
owner = address(0);
}
| 0
|
function checkBalance(address acc, string currencyAndBank) constant returns (uint128 balance) {
bytes32 cab = sha3(currencyAndBank);
return balances[acc][cab];
}
| 0
|
function release(uint256 _id) external {
require(_id > 0);
address _user = msg.sender;
Item storage item = items[_user][_id];
require(item.id == _id);
require(!item.fulfilled);
require(now >= item.releaseTime);
uint256 balance = purpose.balanceOf(this);
require(balance >= item.value);
item.fulfilled = true;
purpose.safeTransfer(item.beneficiary, item.value);
}
| 0
|
modifier onlyRateControl()
{
require(msg.sender == rateControl, "rateControl key required for this function.");
_;
}
| 0
|
function time() public constant returns (uint) {
return now;
}
| 1
|
function vote(address _address) public view returns (int) {
if (lastVoting[_address] == currentVoting) {
return votes[_address];
} else {
return 0;
}
}
| 0
|
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply = totalSupply.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
}
| 0
|
function getItem(address _user, uint256 _id) public view returns (uint256, address, uint256, uint256, bool) {
Item storage item = items[_user][_id];
return (
item.id,
item.beneficiary,
item.value,
item.releaseTime,
item.fulfilled
);
}
| 0
|
function CryptoLinkNet() public {
init();
transferOwnership(TARGET_USER);
}
| 0
|
modifier addressRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor != address(0));
_;
}
| 0
|
function PRNG_Challenge()
private
{
admin = msg.sender;
last_number = 0;
attempts = 0;
winner = 0;
}
| 0
|
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
| 0
|
function withdraw()
public
vestingScheduleConfirmed(msg.sender)
pastCliffTime(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
vestingSchedule.totalAmountWithdrawn = totalAmountVested;
if (amountWithdrawable > 0) {
require(vestingToken.transfer(msg.sender, amountWithdrawable));
emit Withdrawal(msg.sender, amountWithdrawable);
}
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
| 0
|
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
| 0
|
function setContract(string _name, address _address) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(isContract(_address));
require(this != _address);
require(contracts[_name].contractAddress != _address);
require(contracts[_name].isPermanent == false);
address oldAddress = contracts[_name].contractAddress;
contracts[_name].contractAddress = _address;
if(oldAddress == address(0x0)) {
ContractAdded(_name, _address);
} else {
ContractEdited(_name, _address);
}
return true;
}
| 0
|
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellTokenPerEther = newSellPrice;
buyTokenPerEther = newBuyPrice;
}
| 1
|
modifier whenNotPaused() {
require(now >= endDate);
_;
}
| 1
|
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role.");
_;
}
| 0
|
function setVendorWallet(address newVendorWallet) onlyOwner public returns (bool) {
require(newVendorWallet != 0x0);
vendorWallet = newVendorWallet;
return true;
}
| 0
|
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
throw;
}
if (value == 0) throw;
balances[msg.sender] = balances[msg.sender].minus(value);
totalSupply = totalSupply.minus(value);
totalUpgraded = totalUpgraded.plus(value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
| 0
|
function pause() public onlyOwner
{
paused = true;
emit EPause();
}
| 0
|
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
| 0
|
function addDelegator(address minter) public;
function removeDelegator(address minter) public;
function renounceDelegator() public;
function _setFeeRate(uint16 _rate) internal{
_feeRate = _rate;
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transferFrom(_from, _to, _value);
return true;
}
| 0
|
function setMaxParticipants(uint256 _newMax) onlyManager public{
currentPeople=_newMax;
carnitas[lastCarnita].maxPeople=currentPeople;
}
| 0
|
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 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 time() constant returns (uint) {
if(cTime > 0) {
return cTime;
}
return block.timestamp;
}
| 1
|
function transfer(address _to, uint256 _value) stoppable public returns (bool) {
require(msg.data.length >= (2 * 32) + 4);
require(_value < c_totalSupply);
clearExpiredFreezing(msg.sender);
uint from_coins = validBalanceOf(msg.sender);
require(from_coins >= _value);
c_balances[msg.sender] = sub(c_balances[msg.sender], _value);
c_balances[_to] = add(c_balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0
|
function setWallet(address[] _dest) public onlyOwner {
wallet_A = _dest[0];
wallet_B = _dest[1];
wallet_C = _dest[2];
}
| 0
|
function BPESOToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
}
| 1
|
function buyEggs() public payable {
require(initialized);
uint256 eggsBought = calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
eggsBought = SafeMath.sub(eggsBought, calculateDevFee(eggsBought));
ceoAddress.transfer(calculateDevFee(msg.value));
claimedEggs[msg.sender] = SafeMath.add(claimedEggs[msg.sender], eggsBought);
emit Buy(msg.sender, eggsBought);
}
| 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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.