function string | label int64 |
|---|---|
modifier requireAuthorizedLogicContract() {
require(msg.sender == authorizedLogicContractAddress);
_;
} | 0 |
function addComment(string _comment, address _to, bool _aboutBounty, uint _bountyId)
public
{
if (_aboutBounty){
comments.push(Comment(_comment, msg.sender, address(0), _aboutBounty, _bountyId, block.timestamp));
} else {
comments.push(Comment(_comment, msg.sender, _to, _aboutBounty, _bountyId, block.timestamp));... | 0 |
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view retu... | 0 |
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(... | 0 |
function BlockbidCrowdsale(uint _goal, uint _cap, uint _startTime, uint _endTime, uint _rate, uint _earlyBonus, address _wallet)
Crowdsale(_startTime, _endTime, _rate, _wallet) public {
require(_cap > 0);
require(_goal > 0);
standardrate = _rate;
earlybonus = _earlyBonus;
cap = _cap;
goal = _goal;
} | 0 |
function SpaceRegistry() {
spaces.length = START_INDEX;
} | 1 |
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
} | 0 |
function removeFreezer(address freezer) public {
int index = indexOf(c_freezers, freezer);
if (index >= 0) {
uint i = uint(index);
while (i < c_freezers.length - 1) {
c_freezers[i] = c_freezers[i + 1];
}
c_freezers.length--;
}
} | 0 |
function 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 unlock() public {
if(now < unlockedAt) throw;
if(!teamMultisig.send(address(this).balance)) throw;
Unlocked();
} | 1 |
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... | 0 |
function changeContractName(string _newName,string _newSymbol) public {
require(msg.sender==owner || adminOwners[msg.sender].isValid);
name=_newName;
symbol=_newSymbol;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract TruUpgradeableToken is StandardToken {
using SafeMath for uint256;
using SafeMath for uint;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
bool private isUpgradeable = true;
enum UpgradeState {Un... | 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,... | 0 |
function issueTokens (uint256 n, uint256 price, uint deadline) noEther onlyChallengeOwner {
if (now < tokenIssueDeadline) throw;
if (deadline < now) throw;
if (n == 0) throw;
tokenPrice = price;
tokenIssueDeadline = deadline;
tokensToIssue = n;
tokensIssued = 0;
notifyTokenIssued(n, price, deadline);
} | 0 |
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emi... | 0 |
modifier canTransfer() {
require(mintingFinished);
require(now > allowTransferTimestamp);
_;
} | 1 |
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value > 0);
balances[msg.sender] = balances[msg.sender].safeSub(value);
totalSupply = totalSupply.safeSub(value);
totalUpgraded = totalUpgraded... | 0 |
function mint(address account, uint256 amount) external onlyOwner {
require(saleBeginTime < block.timestamp);
require(saleEndTime > block.timestamp);
_transfer(address(this), account, amount);
emit Mint(account, amount, _amountForSale);
} | 0 |
function updateValue(uint256 newValue) {
require(msg.sender == updater || msg.sender == owner);
tokenValue = newValue;
UpdateValue(newValue);
} | 0 |
constructor() public {
totalToken = initialToken;
balances[msg.sender] = publicToken;
balances[founderAddress] = founderToken;
balances[developmentAddress] = developmentToken;
balances[bountyAddress] = bountyToken;
balances[privateSaleAddress] = privateSaleToken;
balances[preSaleAddress] = preSaleToken;
emit Tr... | 0 |
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
} | 1 |
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) returns (bool success) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function removeAdmin(address adminAddress) public onlyOwner {
addressIsAdmin[adminAddress] = false;
} | 0 |
function transferDecimalAmountFrom(address _from, address _to, uint _value) public returns (bool success) {
require(balanceOf[_from]
- tradingBalanceOf[_from][currentTradingSystem]
- exchangeBalanceOf[_from][currentExchangeSystem] >= _value);
require(balanceOf[_to] + (_value) >= balanceOf[_to]);
require(_value <= ... | 0 |
function incAdminEpoch() only_owner() external {
currAdminEpoch++;
admins[currAdminEpoch][msg.sender] = true;
emit AdminEpochInc();
} | 0 |
constructor() public {
owner = msg.sender;
_totalBalance[owner] = _totalSupply;
_accountType[owner] = ReleaseType.Private1;
} | 0 |
function mint(address _to, uint256 _amount) external;
}
contract ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
} | 0 |
function release() public returns(bool) {
uint256 unreleased = releasableAmount();
require(unreleased > 0);
if (releaseTime > 0) {
require(block.timestamp >= releaseTime);
}
released = released.add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
return true;
} | 0 |
function getMintRequestsLength() external view returns (uint length) {
return mintRequests.length;
} | 0 |
function buyTokens () returns (uint256 tokens) {
tokens = msg.value / tokenPrice;
if (now > tokenIssueDeadline) throw;
if (tokensIssued >= tokensToIssue) throw;
tokensIssued += tokens;
if (tokensIssued > tokensToIssue) throw;
DaoAccount account = accountFor(msg.sender, true);
if (account.buyTokens.value(msg.valu... | 0 |
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 v... | 0 |
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
} | 0 |
function time() public constant returns (uint)
{
return block.timestamp;
} | 1 |
function Per_Annum(){
_totalSupply += 4000000000000;
_currentMined += 4000000000000;
contract_owner = msg.sender;
balances[msg.sender] += 4000000000000;
Transfer(this,msg.sender,4000000000000);
} | 0 |
function transferFrom(address from_, address to_, uint value_) external returns (bool);
}
contract BaseICO is Ownable, Whitelisted {
enum State {
Inactive,
Active,
Suspended,
Terminated,
NotCompleted,
Completed
} | 0 |
function addAcceptedContribution(address participant, uint256 ethValue, uint256 parsecValue) private {
contributionOf[participant] = contributionOf[participant].add(ethValue);
parsecsOf[participant] = parsecsOf[participant].add(parsecValue);
raisedFunding = raisedFunding.add(ethValue);
spentParsecs = spentParsecs.a... | 0 |
function isPricingStrategy() public constant returns (bool) {
return true;
} | 0 |
function burn(uint256 _amount) external onlyDestroyer {
require(balances[destroyer] >= _amount && _amount > 0);
balances[destroyer] = balances[destroyer].sub(_amount);
totalSupply = totalSupply.sub(_amount);
Burn(_amount);
} | 0 |
function burnInternal(address _from, uint256 _amount) internal {
require(_from != address(0));
require(_amount > 0);
require(_amount <= balances[_from]);
balances[_from] = balances[_from].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
Transfer(_from, address(0), _amount);
Burn(_from, _amount);
} | 0 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyIfTransfersAllowed {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
} | 0 |
function _transfer(address from, address to, uint256 value) internal {
if (_locked[from].locked) {
for (uint256 i = 0; i < _locked[from].batches.length; i++) {
if (block.timestamp <= _locked[from].batches[i].time) {
require(value <= balanceOf(from).sub(_locked[from].batches[i].amount));
break;
}
}
}
super._tra... | 0 |
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;
contract ERC20 is IERC20 {
using SafeMath for uint256;
... | 0 |
function setGasInTokens(uint _gasInTokens) onlyAdmin external {
gasInTokens = _gasInTokens;
} | 0 |
function ToLend()
public
payable
{
Creditors[msg.sender].Time = now;
Creditors[msg.sender].Invested += msg.value;
Deposited(msg.sender,msg.value);
} | 1 |
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function ... | 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 revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
} | 0 |
function transfer(uint id, address newOwner, string newData)
validID(id) isOwnerOf(id) tradingIsEnabled returns(bool)
{
plots[id].owner = newOwner;
if (bytes(newData).length != 0) {
plots[id].metadata = newData;
}
Transfer(msg.sender, newOwner, id);
addPlot(newOwner, id);
removePlot(msg.sender, id);
return tr... | 0 |
function requestReturn(address _returnAddr) {
require(now <= endDate);
require(returnAddresses[msg.sender] == 0x0);
returnAddresses[msg.sender] = _returnAddr;
ReturnRequested(msg.sender, _returnAddr);
} | 1 |
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedTransferCheck(address(this), tokenOwner, to, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function undo() public {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
} | 1 |
function getName() view public returns(bytes32)
{
return name;
} | 0 |
modifier onlyMaster() {
require(msg.sender == master);
_;
} | 0 |
function max256(uint256 a, uint256 b) internal constant returns (uint256)
{
return a >= b ? a : b;
} | 0 |
modifier onlyOwner() {
require(msg.sender == owner, "Only owner");
_;
} | 0 |
modifier isNotTimeLocked() {
require(now >= timelockedAccounts[msg.sender]);
_;
} | 0 |
function collectRewards() external returns (bool) {
uint256 _amountInVault = _transferIns[msg.sender].amountInVault;
require(_amountInVault > 0, "You have not staked any tokens.");
require(_holdAgeTimestamp(msg.sender) >= _transferIns[msg.sender].stakeMinimumTimestamp,
"You need to stake for the minimum time of 10... | 0 |
function releaseMyVestedTokens() public changesToVestingFreezed(msg.sender) {
releaseVestedTokens(msg.sender);
} | 0 |
modifier notExceedMaximumSupply(uint amount) {
require(totalSupply.plus(amount) <= maximumSupply);
_;
} | 0 |
function updateRenExBalances(RenExBalances _newRenExBalancesContract) external onlyOwner {
emit LogRenExBalancesUpdated(renExBalancesContract, _newRenExBalancesContract);
renExBalancesContract = _newRenExBalancesContract;
} | 0 |
function Wolk()
{
start_block = 3831300;
end_block = 3831900;
balances[msg.sender] = wolkFund;
reservedTokens = 25 * 10**decimals;
allocations[0x564a3f7d98Eb5B1791132F8875fef582d528d5Cf] = 20;
allocations[0x7f512CCFEF05F651A70Fa322Ce27F4ad79b74ffe] = 1;
allocations[0x9D203A36cd61b21B7C8c7Da1d8eeB13f04bb24D9] = ... | 0 |
function symbol() public constant returns (string) {
return symbol;
} | 0 |
function tokenToDecimals(uint256 _amount) private view returns (uint256){
return _amount * (10 ** 12);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
if (_to == address(this)) {
balanceOf[_to] -= _value;
totalSupply -= _value;
Destruction(_value);
}
return true;
} | 0 |
modifier whenPaused() {
require(_paused);
_;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spen... | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
if (_to != address(this)) {
return super.transfer(_to, _value);
}
require(_value <= balances_[msg.sender] && status == 0 && gameTime == 0);
balances_[msg.sender] = balances_[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
ui... | 0 |
function nextForkBlockNumber()
public
constant
returns (uint256)
{
return _nextForkBlockNumber;
} | 0 |
modifier onlyAdmin() {
require(addressIsAdmin[msg.sender] || msg.sender == owner);
_;
} | 0 |
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
function setMerchantBtcDepositAddress(string btcDepositAddress) external onlyMerchant returns (bool) {
require(!isEmptyString(btcDepositAddress), "invalid btc deposit address");
merchantBtcDepositAddress[msg.sender] = btcDepositAddress;
emit MerchantBtcDepositAddressSet(msg.sender, btcDepositAddress);
return true;
... | 0 |
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) publi... | 0 |
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
} | 0 |
modifier onlyDelegator() {
require(isDelegator(msg.sender), "DelegatorRole: caller does not have the Delegator role.");
_;
} | 0 |
function tridentDetails ()
external view returns
(
uint stakeMinimumTimestamp,
uint stakeMaximumTimestamp,
uint256 percentageLower,
uint256 percentageMiddle,
uint256 percentageUpper,
uint256 treasuryPercentage,
uint256 stakeMinimum,
uint256 stakeMaximum,
uint256 maxTotalSupply) {
stakeMinimumTimestamp = _st... | 0 |
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0) ) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
} | 0 |
function owner() public view returns(address payable) {
return _owner;
} | 0 |
function unPaidBurnTokens(uint _burnCount) public;
}
contract BurnableToken is iBurnableToken, SafeMath {
event PaymentEvent(address indexed from, uint amount);
event TransferEvent(address indexed from, address indexed to, uint amount);
event ApprovalEvent(address indexed from, address indexed to, uint amount);
eve... | 1 |
modifier onlyWhenTransferEnabled() {
if (now <= allowTransferTime) {
require(
msg.sender == tracetoMultiSigContract ||
msg.sender == exchangeIEO
);
}
_;
} | 0 |
function getMyDragons() public view returns(uint256){
return hatchery[msg.sender];
} | 0 |
function approve(address spender, uint256 value) public pure returns (bool success){
return false;
} | 0 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityToken is ERC20
{
using SafeMath for uint256;
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591);
string public constant name = "Social Activity Token";
string public constant symbol = "SAT";
uint8 public constant... | 0 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
} | 1 |
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
} | 1 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
... | 0 |
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
require(value > 0, "transferFrom: value is must be greater than zero.");
require(balanceOf(from) >= value, "transferFrom: balance of from address is not enough");
require(_allowances[from][msg.sender] >= value, "tran... | 0 |
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
} | 0 |
function removeVesting(uint256 _vestingId) public onlyOwner {
Vesting storage vesting = vestings[_vestingId];
require(vesting.beneficiary != address(0x0), INVALID_VESTING_ID);
require(!vesting.released , VESTING_ALREADY_RELEASED);
vesting.released = true;
tokensToVest = tokensToVest.sub(vesting.amount);
emit Toke... | 0 |
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
} | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersP... | 1 |
function transferFrom(address _from, address _to, uint _value) whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
require (!isFinalized);
uint256 tokens = safeMult(_value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(totalSupply, tokens);
if (tokenCreationCap... | 1 |
function TUINETWORK()
{
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply;
balances[msg.sender] -= TUI_ALLOCATION;
balances[TUI_ADDRESS] = TUI_ALLOCATION;
} | 0 |
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.d... | 0 |
function plus(uint a, uint b) public pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
} | 0 |
constructor () public payable {
dev = msg.sender;
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
randomContract = new Random();
} | 0 |
function max64(uint64 a, uint64 b) internal constant returns (uint64)
{
return a >= b ? a : b;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.