function
string | label
int64 |
|---|---|
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
} | 0 |
function claimWinnings() public {
require(now > lastTimestamp + 1 days);
require(msg.sender == currentWinner);
msg.sender.transfer(address(this).balance);
} | 0 |
function getTimestamp() view public returns (uint256) {
return now;
} | 1 |
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function transfer(address _to, uint256 _amount)external returns (bool success);
function balanceOf(address _owner) external returns (uint256 balance);
function decimals()external view returns (uint8);
}
contract Vault is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
address public wallet;
event Withdrawn(address _wallet);
function Vault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
} | 0 |
function lock() external onlyOwner vaultLoading {
require(tokensAllocated == tokensToBeAllocated, "Expected to allocate all tokens");
require(token.balanceOf(address(this)) == tokensAllocated, "Vault must own enough tokens to distribute");
lockedAt = block.timestamp;
emit Locked();
} | 0 |
function devFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount, 4), 100);
} | 0 |
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function tokensPurchased() internal constant returns (uint) {
return rate.mul(msg.value).mul(100000000).div(1 ether);
} | 0 |
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function withdrawERC20Token(uint16 tokenCode, address traderAddr, address withdrawalAddr, uint amount) external;
function transferTokens(uint16 tokenCode, address fromAddr, address toAddr, uint amount) external;
function transferTokensTwice(uint16 tokenCode, address fromAddr, address toAddr1, uint amount1, address toAddr2, uint amount2) external;
function exchangeTokens(uint16 tokenCode1, uint16 tokenCode2, address addr1, address addr2, address addrFee, uint amount1, uint fee1, uint amount2, uint fee2) external;
}
contract Treasury is AccessModifiers, TreasuryInterface {
uint constant EMERGENCY_RELEASE_CHALLENGE_PERIOD = 2 days;
bool active = false;
mapping (uint16 => address) public tokenContracts;
mapping (uint176 => uint) public tokenAmounts;
event SetActive(bool active);
event ChangeTokenInfo(uint16 tokenCode, address tokenContract);
event StartEmergencyRelease(address account);
event Deposit(uint16 tokenCode, address account, uint amount);
event Withdrawal(uint16 tokenCode, address traderAddr, address withdrawalAddr, uint amount);
event EmergencyRelease(uint16 tokenCode, address account, uint amount);
mapping (address => uint) public emergencyReleaseSince;
constructor () public {
} | 0 |
function addNewReport(string newReport) public onlyOwner {
reports.push(Report(newReport, now));
} | 1 |
function start_ICO() public onlyOwner atStage(Stages.PREICO)
{
require(now > pre_enddate || eth_received >= 1500 ether);
stage = Stages.ICO;
stopped = false;
ico1_startdate = now;
ico_first = now + 15 days;
ico_second = ico_first + 15 days;
ico_third = ico_second + 15 days;
ico_fourth = ico_third + 15 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function do_declare_finish(uint block_finish) internal {
uint squid = 11;
uint leader;
uint[10] memory progress;
uint winners;
bool finished;
for(uint b = races[race_number].block_start; b <= block_finish; b++){
uint hash = uint(blockhash(b));
uint weather = hash%3;
for(uint boat = 0; boat < races[race_number].boat_count; boat++){
if(squid != boat){
progress[boat] += increment_boat(
hash,
weather,
boat,
races[race_number].boats[boat].class,
races[race_number].boats[boat].variant
);
}
if(progress[boat] >= progress[leader]){
leader = boat;
}
if(b == block_finish - 1){
require(progress[boat] < COURSE_LENGTH,"passed");
}else if(b == block_finish){
finished = finished || progress[boat] >= COURSE_LENGTH;
if(progress[boat] >= COURSE_LENGTH){
winners++;
}
}
}
if(progress[leader] < COURSE_LENGTH && progress[leader] > COURSE_LENGTH/2 && !races[race_number].boats[leader].repellent && squid == 11 && uint(hash)%MODULO_SQUID == 0){
squid = leader;
}
}
require(finished,"unfinished");
races[race_number].block_finish = block_finish;
uint paid = 0;
uint reward = races[race_number].pool * 95 / winners /100;
for( uint boat = 0; boat < races[race_number].boat_count; boat++){
if(progress[boat] >= COURSE_LENGTH){
bank[
races[race_number].boats[boat].owner
] += reward;
paid += reward;
}
}
bank[ msg.sender ] += races[race_number].pool /100;
paid += races[race_number].pool /100;
bank[ blackbeard ] += races[race_number].pool - paid;
emit Finish(race_number, block_finish, msg.sender);
} | 0 |
function SmartVows(string _partner1, address _partner1_address, string _partner2, address _partner2_address, string _marriageDate, string _maritalStatus, string _officiant, string _witnesses, string _location, string coupleImageIPFShash, string marriageLicenceImageIPFShash) public{
partner1_name = _partner1;
partner2_name = _partner2;
partner1_address=_partner1_address;
partner2_address=_partner2_address;
marriageDate =_marriageDate;
maritalStatus = _maritalStatus;
officiant=_officiant;
witnesses=_witnesses;
location=_location;
saveContractEvent("Blockchain marriage smart contract created","Marriage smart contract added to the blockchain");
} | 0 |
function getTimestamp() internal view returns (uint) {
return block.timestamp;
} | 0 |
function withdrawEth() public onlyAdmin(2) {
require(totalDistributed >= softCap, "Too early to retrieve funds");
beneficiary.transfer(address(this).balance);
} | 0 |
function getRefund() public notFinished {
require(totalDistributed >= softCap, "Too early to retrieve funds");
require(invested[msg.sender] > 0, "No eth to refund");
require(
tokenReward.transferFrom(
msg.sender,
address(this),
received[msg.sender].add(bonusReceived[msg.sender])
),
"Cannot retrieve tokens"
);
totalDistributed = totalDistributed.sub(received[msg.sender]);
totalBonusDistributed = totalBonusDistributed.sub(bonusReceived[msg.sender]);
received[msg.sender] = 0;
bonusReceived[msg.sender] = 0;
uint toTransfer = invested[msg.sender];
invested[msg.sender] = 0;
msg.sender.transfer(toTransfer);
} | 0 |
function setTokenLock() onlyOwner public
{
require(tokenLock == false);
tokenLock = true;
} | 0 |
function tokenSetup(address _Tokens1st, address _Balancecs, address _Token, address _Conversion, address _Distribution) onlyPayloadSize(5 * 32) onlyOwner public returns (bool) {
setContract("Token1st", _Tokens1st);
setContract("Balances", _Balancecs);
setContract("Token", _Token);
setContract("Conversion", _Conversion);
setContract("Distribution", _Distribution);
return true;
} | 0 |
function feeFor(address from, address to, uint256 amount) constant external returns (uint256 value) {
uint256 fee = exportFee[from];
if (fee == 0) return 0;
if ((exportFee[from] == 0 && balanceOf[from] != 0 && now < expiry && validAfter[from] <= now) || (balanceOf[to] != 0 && now < expiry && validAfter[to] <= now)) return 0;
return div10(amount*fee, feeDecimals);
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x3135081dE9aEf677b3d7445e6C44Bb385cBD3E6a;
uint constant UNLOCK_DATE = 1548547199;
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
} | 0 |
function changeHolder(uint256 _id, address _newholder) public returns (bool);
}
contract StockExchange {
bool public started = false;
uint256 public stopTimeLength = 7200;
uint256 public stopTime = 0;
uint256 public cap = 50;
address public owner;
address public deusETH;
mapping(uint256 => uint256) public priceList;
mapping(uint256 => address) public holderList;
InterfaceDeusETH private lottery = InterfaceDeusETH(0x0);
event TokenSale(uint256 indexed id, uint256 price);
event TokenBack(uint256 indexed id);
event TokenSold(uint256 indexed id, uint256 price);
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function mintWithFreeze(address _to, uint256 _value, uint256 _unfreezeTimestamp, bool _subsequentUnlock) public onlyMinter returns (bool) {
require(now < _unfreezeTimestamp);
_setHold(_to, _value, _unfreezeTimestamp, _subsequentUnlock);
mint(_to, _value);
return true;
} | 0 |
modifier onlyAdmin(uint8 _level) {
require(level[msg.sender] >= _level );
_;
} | 0 |
function Escrow() {
owner = msg.sender;
} | 0 |
function allowance(address account, address spender) public view returns (uint remaining) {
return allowed[account][spender];
} | 0 |
function signFork(uint256 number, bytes32 hash)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
require(block.blockhash(number) == hash);
delete _nextForkName;
delete _nextForkUrl;
delete _nextForkBlockNumber;
_lastSignedBlockNumber = number;
_lastSignedBlockHash = hash;
_lastSignedTimestamp = block.timestamp;
LogForkSigned(_lastSignedBlockNumber, _lastSignedBlockHash);
} | 0 |
function release(address who) public onlyTransferAgent returns (bool) {
require(tokenContract != address(0x0), "ERC20 Token contract is null, nowhere to release to.");
Holding memory holding = heldTokens[who];
require(!holding.isAffiliate, "To release tokens for an affiliate use partialRelease().");
if(block.timestamp > holding.releaseDate) {
bool res = TokenInterface(tokenContract).hold(who, holding.quantity);
if(res) {
heldTokens[who] = Holding(0, 0, holding.isAffiliate);
emit TokensReleased(who, holding.quantity);
return true;
}
}
return false;
} | 0 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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 LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint constant public lockPeriod1 = 2 years;
uint constant public lockPeriod2 = 24 weeks;
uint constant public lockPeriodForBuyers = 12 weeks;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
bool public isActivated = false;
mapping (address => bool) public whitelistedBeforeActivation;
mapping (address => bool) public isPresaleBuyer;
address public saleAddress;
address public founder1Address;
address public founder2Address;
uint public icoEndTime;
uint public icoStartTime;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
function VinToken(
address _founder1Address,
address _founder2Address,
uint _icoStartTime,
uint _icoEndTime
) public
{
require(_founder1Address != 0x0);
require(_founder2Address != 0x0);
require(_icoEndTime > _icoStartTime);
founder1Address = _founder1Address;
founder2Address = _founder2Address;
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
balances[owner] = totalSupply;
whitelistedBeforeActivation[owner] = true;
} | 0 |
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 |
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
function addEntry(string name, string company, string description, string category, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, ethAddress, block.timestamp, false);
directory[ethAddress] = entry;
entries.push(entry);
return true;
} | 1 |
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);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
constructor() internal {
} | 0 |
modifier onlyAdmin() {
require(msg.sender == adminAddress, "Only admin");
_;
} | 0 |
modifier whenSaleHasEnded() {
require(now >= endTimestamp);
_;
} | 0 |
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
function freezingBalanceInfoOf(address addr, uint index) constant public returns (uint, uint, uint8) {
return (c_freezing_list[addr][index].end_stamp, c_freezing_list[addr][index].num_coins, uint8(c_freezing_list[addr][index].freezing_type));
} | 0 |
function removeMinter(address minter) public onlyOwner{
super._removeMinter(minter);
} | 0 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
} | 0 |
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
} | 0 |
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length >= numWords * 32 + 4);
_;
} | 0 |
function initialize(address _inchwormAddress, address _daiAddress, address payable _deployer) external onlyOwner {
inchWormContract = ERC20Interface(_inchwormAddress);
daiContract = ERC20Interface(_daiAddress);
deployer = _deployer;
pegMoveReadyTime = now;
} | 0 |
function currentTime() public view returns (uint) {
return now;
} | 0 |
function currentTime() public view returns (uint256) {
return now * 1000;
} | 1 |
function DVIP() {
isActive = true;
treasuryBalance = 0;
totalSupply = 0;
name = "DVIP";
symbol = "DVIP";
decimals = 6;
allowTransactions = true;
expiry = 1514764800;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
} | 0 |
function transferFrom(address _from, address _to, uint256 _value)public returns (bool success) {
if (_to == address(0x0)) revert();
if (_value <= 0) revert();
if (balanceOf[_from] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function payoutAmount(address addr) public view returns(uint,uint) {
uint rate = userDeposit[addr].mul(startPercent).div(100000);
uint interestRate = now.sub(userTime[addr]).div(chargingTime);
uint withdrawalAmount = rate.mul(interestRate);
return (withdrawalAmount, interestRate);
} | 0 |
modifier onlyPayloadSize(uint size)
{
if(msg.data.length < size + 4)
{
throw;
}
_;
} | 0 |
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
} | 0 |
modifier onlyOwner() {
if(msg.sender == owner)
_;
} | 0 |
function owner() public view returns (address) {
return data.owner;
} | 0 |
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
} | 0 |
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
} | 0 |
function _transfer(address _from, address _to, uint256 _value) private returns (bool success) {
require(_value <= balances[_from]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function selfDestruct()
external
onlyOwner
{
require(initiationTime + SD_DURATION < now);
emit SelfDestructed(beneficiary);
selfdestruct(beneficiary);
} | 0 |
function mistTokenBase() public { }
function totalSupply() public view returns (uint256) {
return _supply;
} | 0 |
function initiatable(bytes32 _swapID) external view returns (bool) {
return (swapStates[_swapID] == States.INVALID);
} | 0 |
function setEthPriceProvider(address provider) external;
}
contract AnythingAppTokenPreSale is Haltable, PriceReceiver {
using SafeMath for uint;
string public constant name = "AnythingAppTokenPreSale";
AnythingAppToken public token;
InvestorWhiteList public investorWhiteList;
address public beneficiary;
uint public tokenPriceUsd;
uint public totalTokens;
uint public ethUsdRate;
uint public collected = 0;
uint public withdrawn = 0;
uint public tokensSold = 0;
uint public investorCount = 0;
uint public weiRefunded = 0;
uint public startTime;
uint public endTime;
bool public crowdsaleFinished = false;
mapping (address => bool) public refunded;
mapping (address => uint) public deposited;
uint public constant BONUS_LEVEL_1 = 40;
uint public constant BONUS_LEVEL_2 = 35;
uint public constant BONUS_LEVEL_3 = 30;
uint public firstStage;
uint public secondStage;
uint public thirdStage;
uint public constant MINIMAL_PURCHASE = 250 ether;
uint public constant LIMIT_PER_USER = 500000 ether;
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
event NewReferralTransfer(address indexed investor, address indexed referral, uint tokenAmount);
event Refunded(address indexed holder, uint amount);
event Deposited(address indexed holder, uint amount);
modifier preSaleActive() {
require(block.timestamp >= startTime && block.timestamp < endTime);
_;
} | 0 |
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCPreSaleContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 23 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
} | 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);
}
contract BurnableERC20 is ERC20 {
function burn(uint256 amount) public returns (bool burned);
}
contract NokuTokenBurner is Pausable {
using SafeMath for uint256;
event LogNokuTokenBurnerCreated(address indexed caller, address indexed wallet);
event LogBurningPercentageChanged(address indexed caller, uint256 indexed burningPercentage);
address public wallet;
uint256 public burningPercentage;
uint256 public burnedTokens;
uint256 public transferredTokens;
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 0 |
function balanceOf(address _owner)
constant
returns (uint256)
{
return balances[_owner];
} | 0 |
function getHours() returns (uint){
return (block.timestamp / 60 / 60) % 24;
} | 1 |
function setOversight(address addr) onlyOwnerUnlocked setter {
oversightAddress = addr;
} | 0 |
function createTokenContract() internal returns (MintableToken) {
return new EndtimesToken();
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
} | 0 |
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
} | 0 |
function getOrderInfo(Order memory order)
public
view
returns (OrderInfo memory orderInfo)
{
orderInfo.orderHash = getOrderHash(order);
orderInfo.orderTakerAssetFilledAmount = filled[orderInfo.orderHash];
if (order.makerAssetAmount == 0) {
orderInfo.orderStatus = uint8(OrderStatus.INVALID_MAKER_ASSET_AMOUNT);
return orderInfo;
}
if (order.takerAssetAmount == 0) {
orderInfo.orderStatus = uint8(OrderStatus.INVALID_TAKER_ASSET_AMOUNT);
return orderInfo;
}
if (orderInfo.orderTakerAssetFilledAmount >= order.takerAssetAmount) {
orderInfo.orderStatus = uint8(OrderStatus.FULLY_FILLED);
return orderInfo;
}
if (block.timestamp >= order.expirationTimeSeconds) {
orderInfo.orderStatus = uint8(OrderStatus.EXPIRED);
return orderInfo;
}
if (cancelled[orderInfo.orderHash]) {
orderInfo.orderStatus = uint8(OrderStatus.CANCELLED);
return orderInfo;
}
if (orderEpoch[order.makerAddress][order.senderAddress] > order.salt) {
orderInfo.orderStatus = uint8(OrderStatus.CANCELLED);
return orderInfo;
}
orderInfo.orderStatus = uint8(OrderStatus.FILLABLE);
return orderInfo;
} | 0 |
function transfer(address to, uint256 value);
function transferFrom(address from, address to, uint256 value);
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 mul(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function balanceOf(address who) constant returns (uint);
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 safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function duel(address opp) public returns (uint, uint) {
require(block.number >= blockDuelBegin);
require(block.number >= fatigueBlock + player[msg.sender].lastDuel);
require(block.number >= safeBlock + player[opp].lastJoin);
require(!isContract(msg.sender));
player[msg.sender].lastDuel = block.number;
uint ethPlayer = player[msg.sender].wad;
uint ethOpp = player[opp].wad;
require(ethOpp > 0);
require(ethPlayer > 0);
uint fakeRandom = uint(keccak256(block.blockhash(block.number-1), opp, divAmt, block.timestamp));
bool isWin = (fakeRandom % (ethPlayer.add(ethOpp))) < ethPlayer;
address winner = msg.sender;
address loser = opp;
uint amt = ethOpp;
if (!isWin) {
winner = opp;
loser = msg.sender;
amt = ethPlayer;
}
uint cut = amt.mul(divCut) / 1000;
uint realAmt = amt.sub(cut);
divAmt = divAmt.add(cut);
player[winner].wad = player[winner].wad.add(realAmt);
player[loser].wad = 0;
playerList[player[loser].listPosition] = playerList[playerList.length - 1];
player[playerList[playerList.length - 1]].listPosition = player[loser].listPosition;
playerList.length--;
DUEL(msg.sender, opp, isWin, amt);
} | 1 |
function transferOwner_creator(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_creator;
Owner_creator = _to;
emit ChangeOwner_creator(from, _to);} | 0 |
function unlock() public {
require(now > unlockedAt);
uint vaultBalance = token.balanceOf(address(this));
token.transfer(recipient, vaultBalance);
} | 1 |
function getMatchDetails(bytes32 _orderID)
external view returns (
bool settled,
bool orderIsBuy,
bytes32 matchedID,
uint256 priorityVolume,
uint256 secondaryVolume,
uint256 priorityFee,
uint256 secondaryFee,
uint32 priorityToken,
uint32 secondaryToken
) {
matchedID = orderbookContract.orderMatch(_orderID);
orderIsBuy = isBuyOrder(_orderID);
(bytes32 buyID, bytes32 sellID) = orderIsBuy ?
(_orderID, matchedID) : (matchedID, _orderID);
SettlementDetails memory settlementDetails = calculateSettlementDetails(
buyID,
sellID,
getTokenDetails(orderDetails[buyID].tokens)
);
return (
orderStatus[_orderID] == OrderStatus.Settled || orderStatus[_orderID] == OrderStatus.Slashed,
orderIsBuy,
matchedID,
settlementDetails.leftVolume,
settlementDetails.rightVolume,
settlementDetails.leftTokenFee,
settlementDetails.rightTokenFee,
uint32(orderDetails[buyID].tokens >> 32),
uint32(orderDetails[buyID].tokens)
);
} | 0 |
function setEarlyParticipantWhitelist(address addr, bool status, uint minCap, uint maxCap) public onlyOwner {
if (!isWhiteListed) throw;
assert(addr != address(0));
assert(maxCap > 0);
assert(minCap <= maxCap);
assert(now <= endsAt);
if (!isAddressWhitelisted(addr)) {
whitelistedParticipants.push(addr);
Whitelisted(addr, status, minCap, maxCap);
} else {
WhitelistItemChanged(addr, status, minCap, maxCap);
}
earlyParticipantWhitelist[addr] = WhiteListData({status:status, minCap:minCap, maxCap:maxCap});
} | 0 |
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns (bool success) {
if (!DCAssetBackend(backendContract).approveAndCall(msg.sender, _spender, _amount, _extraData)) throw;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
modifier hasntStarted() {
require(!started);
_;
} | 0 |
function forceVoidRace() internal {
chronus.voided_bet=true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
} | 0 |
function isIcoActive() public returns(bool isActive) {
return !isIcoStopped && now < deadline;
} | 1 |
function burn(address burner, uint256 amount) internal {
uint256 random = uint(keccak256(abi.encodePacked(block.difficulty,now,block.number, nonce))) % 999;
nonce++;
if (random > 983) {
uint256 _amount = amount / 100;
IERC20(BXIT).transfer(burner, _amount);
}
} | 0 |
modifier onlyOwner() {
require(
msg.sender == owner,
"ONLY_CONTRACT_OWNER"
);
_;
} | 0 |
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transfer(_to, _value);
return true;
} | 0 |
function setTransferFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
transferFee.prop = _value;
emit SetFee("transfer", "proportional", _value);
return true;
} | 0 |
function getFirstTokens() public {
require(freezOne <= uint64(now));
token.transfer(msg.sender, balances_freez_one[msg.sender]);
} | 0 |
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
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 investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
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 requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(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 setExportFee(address addr, uint256 fee) multisig(sha3(msg.data)) {
uint256 max = 1;
max = pow10(1, decimals);
assert(fee <= max);
exportFee[addr] = fee;
activateExportFeeChargeRecord(addr);
} | 0 |
function bid() public payable onlyActiveAuction {
uint bidAmount = msg.value.sub(bidFee);
require(bidAmount > winningBid.add(minimumBidDelta), "Bid too small");
repayThirdPlace();
updateLosingBidder();
updateWinningBidder(bidAmount, msg.sender);
if(expiryTime < block.timestamp + sixHours){
expiryTime = block.timestamp + sixHours;
}
} | 0 |
function percentageUpper () external view returns (uint256) {
return _percentageUpper;
} | 0 |
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth,contractBalance,marketEggs);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20 {
using SafeMath for uint;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
} | 0 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
CryptoColor storage cryptoColor = cryptoColorData[_tokenId];
uint256 price = cryptoColor.price;
address oldOwner = cryptoColor.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 profit = price.sub(cryptoColor.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(5).div(100);
devOwed = devOwed.add(devCut);
transfer(oldOwner, newOwner, _tokenId);
cryptoColor.lastPrice = price;
cryptoColor.price = getNextPrice(price);
TokenSold(_tokenId, newOwner, price, cryptoColor.price, oldOwner);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
} | 1 |
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferFromHash(spender, from, to, tokens, fee, nonce);
} | 0 |
function status() external view returns (ICOStatus) {
return status(block.timestamp);
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.