function string | label int64 |
|---|---|
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view ret... | 0 |
function canTransferTokens() internal view returns (bool) {
if (msg.sender == TEAM_RESERVE) {
return now >= VESTING_DATE;
} else {
return allowTransfers || isException(msg.sender);
}
} | 1 |
function check_authorization(address _owner, address _trustee) constant returns (bool authorization_status) {
return authorized[_owner][_trustee];
} | 0 |
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.send... | 0 |
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... | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 _allowance);
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
function approve(address _spender, uint256 ... | 0 |
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
} | 0 |
function validPurchase() internal view returns (bool) {
require(!token.mintingFinished());
require(weiRaised <= cap);
require(now >= startTime);
require(now <= endTime);
require(msg.value >= 0.001 ether);
return true;
} | 0 |
function updateEarlyParticipantWhitelist(address addr, uint tokensBought) public {
if (!isWhiteListed) throw;
assert(addr != address(0));
assert(now <= endsAt);
assert(isTierJoined(msg.sender));
if (tokensBought < earlyParticipantWhitelist[addr].minCap && tokenAmountOf[addr] == 0) throw;
uint newMaxCap = earlyPar... | 0 |
function getOrderHash(Order memory order)
internal
view
returns (bytes32 orderHash)
{
orderHash = hashEIP712Message(hashOrder(order));
return orderHash;
} | 0 |
function updatePrice(uint price, uint timeSent)
external
postCheckAutoLiquidate
{
require(msg.sender == oracle);
require(lastPriceUpdate < timeSent && timeSent < now + 10 minutes);
etherPrice = price;
lastPriceUpdate = timeSent;
emit PriceUpdated(price);
} | 0 |
constructor() public{
_supply = 319000000*(10**8);
_balances[freezeOwner] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1560927600, unfreezeValue:9570000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeT... | 0 |
function do_declare_void() internal {
races[race_number].block_finish = races[race_number].block_start;
bank[ blackbeard ] += races[race_number].pool * 99/100;
bank[ msg.sender ] += races[race_number].pool /100;
emit Void(race_number, msg.sender);
} | 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 {
require(token.transfer(to, value));
} | 0 |
function calcBurnFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(burnFee.prop);
fee = fee.add(burnFee.abs);
return fee;
} | 0 |
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane(token);
} | 0 |
function setStartsAt(uint time) onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= time);
assert(time <= endsAt);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
if (lastTierCntrct.finalized()) throw;
uint8 tierPosition = getTierPosition(this);
for (uint8 j =... | 0 |
function signedTransferFromHash(Data storage , address tokenContract, address spender, address from, address to, uint tokens, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedTransferFromSig, tokenContract, spender, from, to, tokens, fee, nonce);
} | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
balances[msg.sender] = safeSub(balances[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(to... | 0 |
function setReferenceTime(uint256 newTime) public onlyOwner {
reference_time = newTime;
} | 0 |
function calcMintFee(uint256 _amount) public view returns (uint256) {
uint256 fee = 0;
fee = _amount.div(decimalpercent);
fee = fee.mul(mintFee.prop);
fee = fee.add(mintFee.abs);
return fee;
} | 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)... | 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;
p... | 0 |
function max256(uint256 a, uint256 b) pure internal returns (uint256) {
return a >= b ? a : b;
} | 0 |
function EcomToken(address _omniTeamAddress, address _foundationAddress) public {
require(_omniTeamAddress != address(0));
require(_foundationAddress != address(0));
omniTeamAddress = _omniTeamAddress;
foundationAddress = _foundationAddress;
totalSupply = TOKENS_SALE_HARD_CAP;
balances[owner] = TOKENS_SALE_HARD_C... | 0 |
function setMasterKey(address addr) onlyOwnerUnlocked {
assert(!masterKeys[addr]);
activateMasterKey(addr);
masterKeys[addr] = true;
SetMasterKey(msg.sender);
} | 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);
}
pragma solidit... | 0 |
function MainToken() public {
init();
transferOwnership(TARGET_USER);
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
return c;
} | 0 |
function stillAllowed() view public returns (uint256) {
return allowedSince() - withdrawn;
} | 0 |
constructor() public
{
name = "ITAM";
decimals = 18;
symbol = "ITAM";
totalTokenSupply = 0;
tokenIssuedAdvSpt = 0;
tokenIssuedTeam = 0;
tokenIssuedMkt = 0;
tokenIssuedEco = 0;
tokenIssuedSale = 0;
fnfIssuedSale = 0;
privateIssuedSale = 0;
publicIssuedSale = 0;
burnTokenSupply = 0;
require(maxAdvSptSupply... | 0 |
function capReached() public view returns (bool) {
return weiRaised >= cap;
} | 0 |
function removeFreezer(address freezer) auth public {
FreezerAuthority(authority).removeFreezer(freezer);
} | 0 |
function withdrawStake(uint _id) public {
require(audits[_id].status == AuditStatus.Completed);
require(auditors[msg.sender].canWithdrawStake[_id]);
require(block.timestamp >= audits[_id].endTime + stakePeriod);
auditors[msg.sender].canWithdrawStake[_id] = false;
address(msg.sender).transfer(audits[_id].stake);
e... | 0 |
function CommonWhitelist() MultiOwnable() public {}
function historyCount() public view returns (uint) {
return history.length;
} | 0 |
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) returns (bool success) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function ownersCount() constant public returns (uint256) {
return owners.length;
} | 0 |
function CostumeToken() public {
balances[msg.sender] = initialSupply;
} | 0 |
modifier isValidCommentIndex(uint i){
require (i < comments.length);
_;
} | 0 |
function issue_vesting_Advisor(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_Advisor >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_Advisor) ) < time ) && ( vestingRelease_Advisor[_time] > 0 ) );
uint tokens = vestin... | 0 |
function getRunDetails(uint _heroId) external view returns (
uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState
) {
uint genes;
address owner;
(,,, genes, owner,,) = ... | 0 |
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
} | 0 |
function discount() public view returns (uint256) {
if (now > endThirdPeriodTimestamp)
return 0;
if (now > endSecondPeriodTimestamp)
return 5;
if (now > endFirstPeriodTimestamp)
return 15;
return 25;
} | 0 |
function donate()
public
payable
{
require(msg.sender != receiver);
require(block.timestamp < (timeStarted + expirationInSeconds));
require(msg.value > 0);
require(minimumAmountRequired != 0);
require(hasBeenClaimed == false);
assert(donationData[msg.sender] + msg.value >= donationData[msg.sender]);
assert(to... | 0 |
function fipsGenerate() internal returns (bytes20 fips) {
fips = ripemd160(block.blockhash(block.number), sha256(msg.sender, block.number, block.timestamp, msg.gas));
if (fipsIsRegistered(fips)) {
return fipsGenerate();
}
return fips;
} | 1 |
modifier isLockTimeEnded(address from){
if (from == founder1Address) {
require(now > icoEndTime + lockPeriod1);
} else if (from == founder2Address) {
require(now > icoEndTime + lockPeriod2);
} else if (isPresaleBuyer[from]) {
require(now > icoEndTime + lockPeriodForBuyers);
}
_;
} | 0 |
function DeusETH(address _fundsKeeper) public {
require(_fundsKeeper != address(0));
owner = msg.sender;
fundsKeeper = _fundsKeeper;
timestamp = now;
} | 0 |
function pause() public;
function unpause() public;
}
contract Burnable {
event Burn(address burner, uint256 value);
constructor () internal {}
function burn(address account, uint256 value) public;
function _burn(address account, uint256 value) internal{
emit Burn(account, value);
} | 0 |
function setContactInformation(string info) onlyOwner public {
contactInformation = info;
} | 0 |
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
} | 0 |
modifier activeForHolder(address holder) {
uint group = holderGroup[holder];
require(activationTime[group] <= now);
_;
} | 1 |
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
} | 0 |
function subtractDarknodeFee(uint256 _value) private pure returns (ValueWithFees memory) {
uint256 newValue = (_value * (DARKNODE_FEES_DENOMINATOR - DARKNODE_FEES_NUMERATOR)) / DARKNODE_FEES_DENOMINATOR;
return ValueWithFees(newValue, _value - newValue);
} | 0 |
function getStats() constant returns (uint256, uint256, bool) {
return (totalContribution, totalSupply, purchasingAllowed);
} | 1 |
function Owned () public {
owner = msg.sender;
} | 0 |
constructor(address _beneficiaryAddress) public {
require(_beneficiaryAddress != address(0));
beneficiary = _beneficiaryAddress;
creator = msg.sender;
tokenReward = ERC20Basic(0x7872b3f20268Eb85120430Cf9abfEEa01F95A91c);
emit LogFundrisingInitialized(beneficiary);
} | 0 |
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
} | 0 |
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
} | 0 |
function timeLockTeam(address _target) public onlySuperAdmins validateAddress(_target) {
require(timelockedAccounts[_target] == 0);
timelockedAccounts[_target] = TEAM_LOCKUP_END;
emit LockedFunds(_target, TEAM_LOCKUP_END);
} | 0 |
function addSigner(address _newSigner) public {
require(isSigner[msg.sender]);
isSigner[_newSigner] = true;
} | 0 |
function unlock() external {
if (now < unlockedAt) throw;
uint256 vested = allocations[msg.sender] * 10**decimals;
if (vested < 0 ) throw;
allocations[msg.sender] = 0;
reservedTokens = safeSub(reservedTokens, vested);
balances[msg.sender] = safeAdd(balances[msg.sender], vested);
Vested(msg.sender, vested);
} | 0 |
function stakeMinimum () external view returns (uint256) {
return _stakeMinimum;
} | 0 |
function _checkAmountForPay(TeamMember memory member) internal pure returns (uint256)
{
if (member.nextWithdrawal == 0)
{
return member.firstTransferValue;
}
return member.eachTransferValue >= member.totalRemainingAmount
? member.totalRemainingAmount
: member.eachTransferValue;
} | 0 |
function claimTeamTokens() public unlockingPeriodStarted {
require (now > beginUnlockDate + 365 days);
require (!teamTokensClaimed);
teamTokensClaimed = true;
_transfer(address(this), teamAddress, 18000000e18);
} | 0 |
function approveAndCall(address spender, uint256 amount, bytes calldata extraData) external returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract CrowdsaleBase is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
addr... | 0 |
function ownerWithdrawUnclaimedCredits() external onlyOwner {
require(now >= TOKEN_WITHDRAWAL_END_DATE);
require(totalFunding >= PRESALE_MINIMUM_FUNDING);
require(!unclaimedCreditsWithdrawn);
unclaimedCreditsWithdrawn = true;
parsecToken.transfer(owner, parsecToken.balanceOf(this));
} | 0 |
function fund()
public
minInvestment
payable
returns (uint)
{
uint tokenCount = msg.value / baseTokenPrice;
uint investment = tokenCount * baseTokenPrice;
if (msg.value > investment && !msg.sender.send(msg.value - investment)) {
throw;
}
investments[msg.sender] += investment;
if (!founder.send(investment)) ... | 1 |
function getAvailableAmount() public constant returns(uint256) {
if (!locked) {
return token.balanceOf(this);
} else {
return amountToWithdrawOnDate(now) - alreadyWithdrawn;
}
} | 1 |
function disableMinting() public {
data.disableMinting();
} | 0 |
function updateFundingEndBlock(uint256 newFundingEndBlock) external onlyFundWallet {
require(currentBlock() < fundingEndBlock);
require(currentBlock() < newFundingEndBlock);
fundingEndBlock = newFundingEndBlock;
} | 0 |
function sendBadge(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 r... | 0 |
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function PreIco(uint256 initialValue, address initialUpdater, uint256 end) {
tokenValue = initialValue;
updater = initialUpdater;
startBlock = block.number;
endTime = end;
} | 0 |
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from... | 0 |
modifier ownerOnly() {
require(msg.sender == owner);
_;
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 14 days;
ico_second = ico_first + 14 days;
ico_third = ico_second + 14 days;
ico_fourth = ico_third + 14 days;
} | 0 |
function 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 WGP is ERC20
{ using S... | 0 |
function approve(address spender, uint tokens) public whenNotPaused returns (bool) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
} | 0 |
function getTotalAmountOfTokens(uint256 _weiAmount) internal view returns (uint256) {
uint256 currentDate = now;
uint256 currentPeriod = getPeriod(currentDate);
uint256 amountOfTokens = 0;
if(currentPeriod < 4){
if(_weiAmount < weiMinSale[currentPeriod]){
return 0;
}
amountOfTokens = (_weiAmount.mul(rates[curre... | 1 |
function mint(address _to, uint256 _amount) external onlyMinter canMint returns (bool) {
require(balances[_to] + _amount > balances[_to]);
require(totalSupply + _amount > totalSupply);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
} | 0 |
function transferFromTreasury(address to, uint256 amount) multisig(sha3(msg.data)) {
assert(treasuryBalance >= amount);
treasuryBalance -= amount;
balanceOf[to] += amount;
activateAccount(to);
} | 0 |
function auditorCanWithdrawStake(uint _id, address _auditor) public view returns(bool) {
if(auditors[_auditor].stakedInAudit[_id] && auditors[_auditor].canWithdrawStake[_id]) {
return true;
}
return false;
} | 0 |
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (signature.length != 65) {
return (address(0));
}
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
if (v < 27) {
... | 0 |
function getLockedAmount_dakehus(address _dakehu)
public
constant
returns (uint256)
{
uint256 dakehuDate = dakehus_dakehuDate[_dakehu];
uint256 lockedAmt = dakehus_locked[_dakehu];
if (now <= dakehuDate + (30 * 1 days)) {return lockedAmt;}
if (now <= dakehuDate + (30 * 2 days)) {return lockedAmt.mul(23).div(24)... | 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, uint256 value... | 0 |
constructor () internal {
_owner = 0xfc0281163cFeDA9FbB3B18A72A27310B1725fD65;
emit OwnershipTransferred(address(0), _owner);
} | 0 |
function approveAndCall(address _caller, address _spender, uint256 _amount, bytes _extraData) onlyAsset returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[_caller]);
allowance[_caller][_spender] = _amount;
activateAccount(_caller);
activateAccount(_spender);
activateAllowanceRecord(_caller,... | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public
returns (bool success)
{
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
} | 0 |
modifier onlyRenExSettlementContract() {
require(msg.sender == address(settlementContract), "not authorized");
_;
} | 0 |
function lock(uint _expiration) onlyowner returns (bool) {
if (_expiration > block.timestamp && expiration == 0) {
expiration = _expiration;
return true;
}
return false;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
as... | 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(tokenOwner, spender, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken {
function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, stri... | 0 |
function totalSupply() public view returns (uint256 total_Supply) {
total_Supply = _totalsupply;
} | 0 |
function swap() external onlyWhitelisted {
if (now >= _lastReset + _period) {
_reset();
}
require(_remaining != 0, "swap: no tokens available");
require(_infos[msg.sender].availableTokens != 0, "swap: no tokens available for swap");
require(now >= _infos[msg.sender].lastSwapTimestamp + _period, "swap: msg.sender ... | 0 |
function balanceOf(address _owner)public view returns (uint256 balance) {
return balances[_owner];
} | 0 |
function adjustPhaseBasedOnTime() internal {
if (now >= closingTime) {
if (phase != Phases.AfterIco) {
phase = Phases.AfterIco;
}
} else if (now >= icoOpeningTime + ICO_DURATION_A + ICO_DURATION_B) {
if (phase != Phases.MainIcoC) {
phase = Phases.MainIcoC;
}
} else if (now >= icoOpeningTime + ICO_DURATION_A ) ... | 0 |
function withdrawMarketingAndCommunityOutreach() public onlyOwner {
require (MarketingAndCommunityOutreachAccumulated > 0);
owner.transfer(MarketingAndCommunityOutreachAccumulated);
MarketingAndCommunityOutreachAccumulated = 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.