function string | label int64 |
|---|---|
function getToken()
public
returns(address)
{
return address(token);
} | 0 |
function activateMasterKey(address addr) internal {
if (!masterKeyActive[addr]) {
masterKeyActive[addr] = true;
masterKeyIndex.push(addr);
}
} | 0 |
modifier whenUpgradeDisabled() {
require(upgradeAgent == address(0));
_;
} | 0 |
function setTierRates(uint256 tier1, uint256 tier2, uint256 tier3, uint256 tier4)
external onlyOwner whenNotPaused {
require(tier1 > 0 && tier2 > 0 && tier3 > 0 && tier4 > 0);
require(tier1 > tier2 && tier2 > tier3 && tier3 > tier4);
rate = tier1;
rateTier2 = tier2;
rateTier3 = tier3;
rateTier4 = tier4;
} | 0 |
function transfer(address _from, address _to, uint256 _tokenId) public onlyGrantedContracts {
ownershipTokenCount[_to]++;
assetIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete assetIndexToApproved[_tokenId];
}
} | 1 |
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 |
function airdrop(address [] _holders,uint256 paySize) external
onlyOwner
{
uint256 count = _holders.length;
assert(paySize.mul(count) <= balanceOf(msg.sender));
for (uint256 i = 0; i < count; i++) {
transfer(_holders [i], paySize);
airdropSupply = airdropSupply.add(paySize);
}
Wasted(owner, airdropSupply, now)... | 1 |
function tokensBack() onlyOwner public {
if(now > endTime){
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
}
tokenFree = sharesTokenAddress.balanceOf(this);
} | 1 |
function getTotalAllowed(address _owner) view public returns(uint256)
{
return totalAllowed[_owner];
} | 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)... | 0 |
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTra... | 0 |
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, uint25... | 0 |
constructor() public
{
name = "LNXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
function setEndsAt(uint _endsAt) public onlyOwner {
require(_endsAt > now);
endsAt = _endsAt;
EndsAtChanged(_endsAt);
} | 0 |
function finalize() onlyOwner public {
require(msg.sender == wallet);
require(now >= 1546300799);
wallet.transfer(this.balance);
} | 1 |
function transfer(address _to, uint256 _value) {
_transfer(msg.sender, _to, _value);
require( now > 1509381941);
} | 1 |
function claimFreeCrab() public{
require(initialized);
require(hatchery[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatchery[msg.sender] = 300;
} | 0 |
function withdraw(ERC20 _token, address _to, uint256 _value) external onlyOwner onUnlocked returns (bool) {
return _token.transfer(_to, _value);
} | 0 |
function WithdrawETH(uint _amount) {
require(msg.sender == alfatokenteam);
msg.sender.transfer(_amount);
} | 0 |
function setBackend(address _backendContract) multisig(sha3(msg.data)) {
backendContract = _backendContract;
} | 0 |
function pingTimestamp() returns (uint) {
return block.timestamp;
} | 0 |
constructor(ReadableI _makerDAOMedianizer) {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
} | 0 |
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
} | 0 |
function transfer(address to, uint value) public returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BeefLedger is ERC20, SafeMath
{
string public constant name = "BeefLedger";
string public co... | 0 |
function invest() public {
targetCrowdsale.contribute.value(this.balance)();
} | 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 upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken
{
address public upgradeMaster;
UpgradeTarget public upgradeTarget;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event LogUpgrade(address ind... | 0 |
function mul(int256 a, int256 b) internal pure returns (int256) {
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN));
int256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function advisorIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advisorVestingTime);
uint nowTime = now;
require( nowTime > advVestingTimer[_time] );
uint tokens = advisorVestingSupply;
require(tokens == advVestingBalances[_time]);
require(maxAdvisorSupply >= token... | 0 |
function balanceOf(address who) constant returns (uint);
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 _beneficia... | 0 |
function setMultisig(address addr) internal {
require(addr != 0);
multisigWallet = addr;
} | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
l... | 0 |
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) ... | 0 |
function transferToAddress(address _to, uint256 _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value, _data);
... | 0 |
function walletCreatedTimestamp(address _wallet) public view returns (uint256) {
return whitelist[_wallet].createdTimestamp;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface InvestorToken {
function transferInvestorTokens(address, uint256);
}
contract Exchange is RBAC {
using SafeMath for uint256;
using BytesDeserializer for ... | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, u... | 0 |
function checkGoalReached() public {
require(now >= icoEnds.date);
if (pre_tokensSold.add(tokensSold) >= fundingGoal){
tokenReward.burn();
emit GoalReached(tokenOwner, amountRaised);
}
crowdsaleEnded = true;
} | 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)... | 0 |
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract BonusFinalizeAgent is FinalizeAgent {
using SafeMath for uint;
Crowdsale public crowdsale;
uint public bonusBasePoints;
uint private constant basePointsDivisor = 10000;
address public teamMultisig;
uint public allocatedBonus;
function BonusFinal... | 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) in... | 0 |
function getLockedAmount_jiedians(address _jiedian)
public
constant
returns (uint256)
{
uint256 jiedianDate = jiedians_jiedianDate[_jiedian];
uint256 lockedAmt = jiedians_locked[_jiedian];
if (now <= jiedianDate + (30 * 1 days)) {return lockedAmt;}
if (now <= jiedianDate + (30 * 2 days)){return lockedAmt.mul(11... | 0 |
function getInvestorCount() constant returns(uint32) {
return investorsCount + knownReserved + unknownReserved;
} | 0 |
function PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 32500000 * 10 ** 18;
bonusInPreSale... | 0 |
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress);
}
contract theCyberGatekeeper {
address private constant THECYBERADDRESS_ = 0x97A99C819544AD0617F48379840941eFbe1bfAE1;
uint8 private constant MAX... | 0 |
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... | 0 |
function diff(uint a, uint b) internal pure returns (uint) {
return a > b ? sub(a, b) : sub(b, a);
} | 0 |
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
} | 0 |
function getLockBalance(address account) internal returns (uint256) {
uint256 lockTypeIndex;
uint256 amountLockedTokens = 0;
uint256 resultFreePercent = 0;
uint256 duration = 0;
uint256 i;
lockTypeIndex = lockAccountInfo[account].lockType;
if (lockTypeIndex >= 1) {
if (lockTypeIndex <= LOCK_TYPE_MAX) {
lockTyp... | 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);
}
contract Stan... | 0 |
function add(address _wallet) internal {
require(_wallet != address(0));
require(!isAllowed[_wallet]);
history.push(_wallet);
isAllowed[_wallet] = true;
AddedEvent(_wallet);
} | 0 |
function ProofOfExistence(){
manager = msg.sender;
created = "cryptonomica.net";
} | 1 |
function buyTokens(address beneficiary) notPaused public payable {
require(beneficiary != 0x0);
if (msg.sender == wallet) {
require(hasEnded());
require(!goalReached);
}
else {
require(validPurchase());
}
weiRaised = weiRaised.add(msg.value);
if (weiContributed[beneficiary] > 0) {
weiContributed[beneficiary]... | 0 |
function changeMultiSig(address _newMultisig)
external
onlyV12MultiSig
onlyValidAddress(_newMultisig)
{
v12MultiSig = _newMultisig;
emit ChangedMultisig(_newMultisig);
} | 0 |
function _burnFrom(address account, uint256 amount) internal {
require(amount <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
amount);
_burn(account, amount);
} | 0 |
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
fun... | 0 |
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
I... | 0 |
function _vote(string name, uint value, address voter) private {
require(babyName == 0);
bytes10 name10 = normalizeAndCheckName(bytes(name));
if (leaderboard[name10] != 0) {
uint newVal = leaderboard[name10];
newVal = addToPart(newVal, S_SCORE_POS, S_SCORE_SIZE, value);
newVal = addToPart(newVal, S_VOTES_POS, S_V... | 1 |
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 _v... | 0 |
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
} | 1 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(locked[msg.sender] < now);
require(transfersEnabled);
return super.transfer(_to, _value);
} | 0 |
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while... | 0 |
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) public {
target = _target;
} | 0 |
function getTime() internal constant returns (uint) {
return now;
} | 1 |
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sende... | 0 |
function name() public constant returns (string name) { name; }
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(ad... | 0 |
function enableRefunds() onlyOwner {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
} | 0 |
function DaoAccount (address _owner, address _challengeOwner) noEther {
owner = _owner;
daoChallenge = msg.sender;
tokenBalance = 0;
challengeOwner = _challengeOwner;
} | 0 |
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMa... | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != address(0));
_allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transferOwnership(address newOwner) public{
require(msg.sender == owner, "Ownable: only owner transfer ownership");
addMinter(newOwner);
addDelegator(newOwner);
removeMinter(owner);
removeDelegator(owner);
super._transferOwnership(newOwner);
} | 0 |
function setTokenLockUp() onlyOwner public
{
require(tokenLock == true);
tokenLock = false;
} | 0 |
function acceptOwnership(Data storage self) public {
require(msg.sender == self.newOwner);
OwnershipTransferred(self.owner, self.newOwner);
self.owner = self.newOwner;
self.newOwner = address(0);
} | 0 |
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_t... | 0 |
function migrateFrom(address _from, uint256 _value);
}
contract OBGAllocation {
uint256 constant totalAllocations = 30000;
mapping (address => uint256) allocations;
ProspectorsObligationToken obg;
uint256 unlockedAt;
uint256 tokensCreated = 0;
function OBGAllocation(address _prospectors_team) internal {
obg = Pr... | 0 |
function removeFreezer(address freezer) public {
int index = indexOf(c_freezers, freezer);
if (index >= 0) {
uint i = uint(index);
while (i < c_freezers.length - 1) {
c_freezers[i] = c_freezers[i + 1];
}
c_freezers.length--;
}
} | 0 |
function CLXTokenSale(address _tokenToBeUsed, address _wallet)public nonZeroAddress(_tokenToBeUsed) nonZeroAddress(_wallet){
token = Token(_tokenToBeUsed);
vault = new Vault(_wallet);
uint256[] memory startTimes = new uint256[](2);
uint256[] memory endTimes = new uint256[](2);
uint256[] memory hardCaps = new uint2... | 0 |
function resetAction(bytes32 hash) internal {
address addr = functionCalls[hash];
functionCalls[hash] = 0x0;
functionCalling[addr] = bytes32(0);
} | 0 |
function set_centralAccount(address central_Acccount) external onlyOwner
{
central_account = central_Acccount;
} | 0 |
function SharenewProduct(string memory uHeadline, string memory uExplain, string memory uImageList, string memory uShowDemo,string memory uCate, uint uPrice, string memory pname) public {
uint256 newpid = getProductID();
newProduct[pname].time = now;
newProduct[pname].senderaddress = msg.sender;
newProduct[pname].h... | 0 |
function disablePurchasing() onlyOwner {
purchasingAllowed = false;
} | 1 |
function burn(uint256 _value) public onlyOwner
returns (bool success)
{
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
avaliableSupply = avaliableSupply.sub(_value);
emit Burn(msg.sender, _value);
return true;
} | 0 |
constructor(address recipient) public {
_mint(recipient, INITIAL_SUPPLY);
} | 0 |
function endGame(address _gameOpponent, uint8 _gameResult) onlyOwner public {
require(gameOpponent != address(0) && gameOpponent == _gameOpponent);
uint256 amount = address(this).balance;
uint256 opAmount = gameOpponent.balance;
require(_gameResult == 1 || (_gameResult == 2 && amount >= opAmount) || _gameResult == ... | 0 |
function signedApprove(Data storage self, address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
require(self.transferable);
bytes32 hash = signedApproveHash(self, tokenOwner, spender, tokens, fee, nonce);
require(tokenOwner != address(0... | 0 |
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_t... | 0 |
modifier whenPaused() {
require(_paused);
_;
} | 0 |
function CrowdSale_AssignOwnership(address newOwner)public onlyOwner
{
require( newOwner != 0x0);
balances[newOwner] = (balances[newOwner]).add(balances[owner]);
balances[owner] = 0;
owner = newOwner;
emit Transfer(msg.sender, newOwner, balances[newOwner]);
} | 0 |
function investments() public constant returns(uint){
return totalInvestments;
} | 0 |
function decimals() public constant returns (uint8) {
return decimals;
} | 0 |
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);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (b... | 0 |
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
require(started);
if(getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
uint256 commision = SafeMath.div(amount, 20);... | 0 |
function setMinter(address _minter) external onlyOwner {
minter = _minter;
} | 0 |
function nistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543804200, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543805300, freezed: tru... | 0 |
function buySuperDragon() public payable {
require(isEnabled);
require(initialized);
uint currenPrice = SafeMath.add(SafeMath.div(SafeMath.mul(lastPrice, 4),100),lastPrice);
require(msg.value > currenPrice);
uint256 timeSpent = SafeMath.sub(now, snatchedOn);
userReferralEggs[superPowerFulDragonOwner] += SafeMath.... | 0 |
modifier onlyCustodian() {
require(controller.isCustodian(msg.sender), "sender not a custodian.");
_;
} | 0 |
function setUpgradeMaster(address _master) public onlyUpgradeMaster {
require(_master != address(0));
upgradeMaster = _master;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupTeam is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
ad... | 0 |
function adminshipLevel(address _newAdmin, uint8 _level) public onlyAdmin(2) {
require(_newAdmin != address(0), "Address cannot be zero");
level[_newAdmin] = _level;
emit AdminshipUpdated(_newAdmin, _level);
} | 0 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 3