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 returns (uint256) {
return totalSupply_;
}
| 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.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 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(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
string public symbol = "CCB";
string public name = "Cursed Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
address public owner = 0x55516b579E56C1287f0700eddDa352C2d2c5b3b6;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CursedToken() public {
}
| 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 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address _owner) public constant returns (uint256){
return balances[_owner];
}
| 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 = earlyParticipantWhitelist[addr].maxCap;
newMaxCap = newMaxCap.minus(tokensBought);
earlyParticipantWhitelist[addr] = WhiteListData({status:earlyParticipantWhitelist[addr].status, minCap:0, maxCap:newMaxCap});
}
| 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({unfreezeTime:1560928200, unfreezeValue:14355000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1560928800, unfreezeValue:14355000*(10**8), freezed: true}));
}
| 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; j < tierPosition; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
assert(time >= crowdsale.endsAt());
}
startsAt = time;
StartsAtChanged(startsAt);
}
| 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(totalUpgraded, value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
| 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);
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 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 |
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_CAP;
}
| 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 solidity ^0.5.0;
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
| 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 == advSptVestingSupplyPerTime * advSptVestingTime, "Invalid AdvSpt Supply");
require(maxTeamSupply == teamVestingSupplyPerTime * teamVestingTime, "Invalid Team Supply");
require(maxMktSupply == mktVestingSupplyFirst + ( mktVestingSupplyPerTime * ( mktVestingTime - 1 ) ) , "Invalid Mkt Supply");
require(maxEcoSupply == ecoVestingSupplyFirst + ( ecoVestingSupplyPerTime * ( ecoVestingTime - 1 ) ) , "Invalid Eco Supply");
uint fnfPercent = 0;
for(uint i = 0; i < fnfSaleLockTime; i++)
{
fnfPercent = fnfPercent.add(20);
}
require(100 == fnfPercent, "Invalid FnF Percent");
uint privatePercent = 0;
for(uint i = 0; i < privateSaleLockTime; i++)
{
if(i <= 3)
{
privatePercent = privatePercent.add(20);
}
else
{
privatePercent = privatePercent.add(10);
}
}
require(100 == privatePercent, "Invalid Private Percent");
require(maxTotalSupply == maxAdvSptSupply + maxTeamSupply + maxMktSupply + maxEcoSupply + maxSaleSupply, "Invalid Total Supply");
require(maxSaleSupply == maxFnFSaleSupply + maxPrivateSaleSupply + maxPublicSaleSupply, "Invalid Sale Supply");
}
| 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);
emit WithdrawedStake(_id, msg.sender, audits[_id].stake);
}
| 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 = vestingRelease_Advisor[_time];
require(maxSupply_Advisor >= issueToken_Advisor.add(tokens));
balances[_to] = balances[_to].add(tokens);
vestingRelease_Advisor[_time] = 0;
issueToken_Total = issueToken_Total.add(tokens);
issueToken_Advisor = issueToken_Advisor.add(tokens);
emit Issue_advisor(_to, tokens);
}
| 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,,) = edCoreContract.getHeroDetails(_heroId);
(_heroPower,,,,) = edCoreContract.getHeroPower(genes, dungeonDifficulty);
_heroStrength = (genes / (32 ** 8)) % 32 + 1;
_heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
_heroHealth = heroIdToHealth[_heroId];
Monster memory monster = heroIdToMonster[_heroId];
_monsterCreationTime = monster.creationTime;
bool _dungeonRunEnded = monster.level > 0 && (
_heroHealth == 0 ||
now > _monsterCreationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime)
);
if (monster.level == 0) {
_heroHealth = _heroInitialHealth;
_monsterLevel = 1;
_monsterInitialHealth = monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 0;
} else if (_dungeonRunEnded) {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 3;
} else if (now > _monsterCreationTime + monsterFleeTime) {
_heroHealth -= monster.level + monsterStrength;
_monsterCreationTime += monsterFleeTime;
_monsterLevel = monster.level + 1;
_monsterInitialHealth = _monsterLevel * monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 1;
} else {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
}
}
| 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(totalAmountRaised + msg.value >= totalAmountRaised);
assert(numPayments + 1 >= numPayments);
donationData[msg.sender] += msg.value;
totalAmountRaised += msg.value;
numPayments += 1;
}
| 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;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
function CrowdsaleBase(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
| 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)) {
throw;
}
uint transactionId = 0;
for (uint i = 0; i < 32; i++) {
uint b = uint(msg.data[35 - i]);
transactionId += b * 256**i;
}
LATPTransaction(transactionId, investment, now);
return tokenCount;
}
| 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 remaining);
function mint(address _owner, uint256 _amount) returns (bool success);
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _from, address indexed _to, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract swap{
address public beneficiary;
TokenInterface public tokenObj;
uint public price_token;
uint256 public WEI_PER_FINNEY = 1000000000000000;
uint public BILLION = 1000000000;
uint public expiryDate;
function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){
beneficiary = sendEtherTo;
tokenObj = TokenInterface(adddressOfToken);
price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY;
expiryDate = now + durationInDays * 1 days;
}
| 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, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 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 SafeMath for uint256;
string public constant name = "W Green Pay";
string public constant symbol = "WGP";
uint8 public constant decimals = 18;
uint public _totalsupply;
uint public maxCap_MInt = 60000000 * 10 ** 18;
address public ethFundMain = 0x67fd4721d490A5E609cF8e09FCE0a217b91F1546;
uint256 public mintedtokens;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
bool stopped = false;
uint256 public ico_startdate;
uint256 public ico_enddate;
uint256 public ETHcollected;
bool public lockstatus;
bool public mintingFinished = false;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event Mint(address indexed from, address indexed to, uint256 amount);
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
}
| 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[currentPeriod])).div(uint256(10**8));
}
return amountOfTokens;
}
| 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) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
| 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);}
if (now <= dakehuDate + (30 * 3 days)) {return lockedAmt.mul(22).div(24);}
if (now <= dakehuDate + (30 * 4 days)) {return lockedAmt.mul(21).div(24);}
if (now <= dakehuDate + (30 * 5 days)) {return lockedAmt.mul(20).div(24);}
if (now <= dakehuDate + (30 * 6 days)) {return lockedAmt.mul(19).div(24);}
if (now <= dakehuDate + (30 * 7 days)) {return lockedAmt.mul(18).div(24);}
if (now <= dakehuDate + (30 * 8 days)) {return lockedAmt.mul(17).div(24);}
if (now <= dakehuDate + (30 * 9 days)) {return lockedAmt.mul(16).div(24);}
if (now <= dakehuDate + (30 * 10 days)) {return lockedAmt.mul(15).div(24);}
if (now <= dakehuDate + (30 * 11 days)) {return lockedAmt.mul(14).div(24);}
if (now <= dakehuDate + (30 * 12 days)) {return lockedAmt.mul(13).div(24);}
if (now <= dakehuDate + (30 * 13 days)) {return lockedAmt.mul(12).div(24);}
if (now <= dakehuDate + (30 * 14 days)) {return lockedAmt.mul(11).div(24);}
if (now <= dakehuDate + (30 * 15 days)) {return lockedAmt.mul(10).div(24);}
if (now <= dakehuDate + (30 * 16 days)) {return lockedAmt.mul(9).div(24);}
if (now <= dakehuDate + (30 * 17 days)) {return lockedAmt.mul(8).div(24);}
if (now <= dakehuDate + (30 * 18 days)) {return lockedAmt.mul(7).div(24);}
if (now <= dakehuDate + (30 * 19 days)) {return lockedAmt.mul(6).div(24);}
if (now <= dakehuDate + (30 * 20 days)) {return lockedAmt.mul(5).div(24);}
if (now <= dakehuDate + (30 * 21 days)) {return lockedAmt.mul(4).div(24);}
if (now <= dakehuDate + (30 * 22 days)) {return lockedAmt.mul(3).div(24);}
if (now <= dakehuDate + (30 * 23 days)) {return lockedAmt.mul(2).div(24);}
if (now <= dakehuDate + (30 * 24 days)) {return lockedAmt.mul(1).div(24);}
return 0;
}
| 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) 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 |
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, _spender);
TokenRecipient spender = TokenRecipient(_spender);
assert(Relay(assetAddress).relayReceiveApproval(_caller, _spender, _amount, _extraData));
Approval(_caller, _spender, _amount);
return true;
}
| 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;
assert(c / a == b);
return c;
}
| 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, string _name, string _symbol, address _tokenowner )returns (address){}
function transfer ( address _address , uint256 amount ){}
function share()returns(uint256){}
function totalSupply()returns(uint256){}
function initialSupply()returns(uint256){}
}
contract Cents is ERC20 {
using strings for *;
string public standard = 'Token 1.0';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public _owner;
address public owner;
address public manager;
address public Centspooladdress;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address =>bool ) public accountFreeze;
uint accountCount;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
event FrozenFunds ( address target, bool frozen );
event TTLAccounts ( uint accounts );
event TTLSupply ( uint supply ) ;
event Burn(address indexed from, uint256 value);
function Cents() {
uint256 _initialSupply = 100000000 ;
uint8 decimalUnits = 0;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "Cents";
symbol = "Cents";
decimals = decimalUnits;
owner = msg.sender;
}
| 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 can not call this method now");
uint256 toSwap = _infos[msg.sender].availableTokens;
if (toSwap > _publicLimit) {
toSwap = _publicLimit;
}
if (toSwap > _remaining) {
toSwap = _remaining;
}
if (toSwap > _oldToken.balanceOf(msg.sender)) {
toSwap = _oldToken.balanceOf(msg.sender);
}
_swap(toSwap);
_update(toSwap);
_remaining = _remaining.sub(toSwap);
emit TokensSwapped(msg.sender, toSwap);
}
| 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 ) {
if (phase != Phases.MainIcoB) {
phase = Phases.MainIcoB;
}
} else if (now >= icoOpeningTime ) {
if (phase != Phases.MainIcoA) {
phase = Phases.MainIcoA;
}
} else if (now >= preIcoOpeningTime + PRE_ICO_DURATION_A + PRE_ICO_DURATION_B) {
if (phase != Phases.PreIcoC) {
phase = Phases.PreIcoC;
}
} else if (now >= preIcoOpeningTime + PRE_ICO_DURATION_A ) {
if (phase != Phases.PreIcoB) {
phase = Phases.PreIcoB;
}
} else if (now >= preIcoOpeningTime ) {
if (phase != Phases.PreIcoA) {
phase = Phases.PreIcoA;
}
} else if (phase == Phases.PreStart) {
setDefaultParamsIfNeeded();
phase = Phases.PreIcoA;
}
}
| 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.