function string | label int64 |
|---|---|
function addMessage(string msgStr) payable {
Message memory newMsg;
newMsg.message = msgStr;
newMsg.from = msg.sender;
newMsg.timestamp = block.timestamp;
messages[messagesIndex] = newMsg;
messagesIndex += 1;
messagesIndex = messagesIndex % 10;
postedMessages++;
} | 1 |
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract Basic... | 0 |
function approveAndCall(address spender, uint tokens, bytes _data) public returns (bool success) {
success = data.approveAndCall(this, spender, tokens, _data);
} | 0 |
function acceptOwnership() public;
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function getCurrentTime() internal constant returns (uint) {
return now;
} | 1 |
function advSptIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advSptVestingTime);
uint nowTime = now;
require( nowTime > advSptVestingTimer[_time] );
uint tokens = advSptVestingSupplyPerTime;
require(tokens <= advSptVestingBalances[_time]);
require(tokens > 0);
r... | 0 |
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) ... | 0 |
function div(uint256 a, uint256 b) internal pure
returns (uint256)
{
uint256 c = a / b;
return c;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances_[msg.sender]);
balances_[msg.sender] = balances_[msg.sender].sub(_value);
balances_[_to] = balances_[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
} | 0 |
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
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) publ... | 0 |
function UpgradeableToken(address _upgradeMaster) public {
upgradeMaster = _upgradeMaster;
} | 0 |
function totalSupply() public view returns (uint256) {
return totalSupplyTokens;
} | 0 |
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
} | 0 |
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
} | 0 |
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function HodlFor(address _purpose, address _dubi, address _hodler) public {
require(_purpose != address(0));
require(_hodler != address(0));
purpose = Purpose(_purpose);
changeDubiAddress(_dubi);
hodler = Hodler(_hodler);
} | 0 |
function randInt(uint max, uint seedswitch) private constant returns (uint randomNumber) {
return( uint(sha3(block.blockhash(block.number-1), block.timestamp + seedswitch) ) % max + 1 );
} | 1 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
uint damageByMonster;
uint damageByH... | 0 |
function ReleaseDate() public constant returns (uint) { return Date; }
function WithdrawEnabled() public constant returns (bool) { return Date > 0 && Date <= now; }
function() public payable { deposit(); }
function deposit() public payable {
if (msg.value > 0) {
if (msg.value >= MinimumDeposit())
Deposits[msg.sen... | 1 |
modifier canTransfer(address sender) {
require(released || transferAgents[sender]);
_;
} | 0 |
function noteBallotDeployed(bytes32 democHash) external;
function upgradeMe(address newSC) external;
}
contract safeSend {
bool private txMutex3847834;
function doSafeSend(address toAddr, uint amount) internal {
doSafeSendWData(toAddr, "", amount);
} | 0 |
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) throw;
bought_tokens = true;
time_bought = now;
token.proxyPayment.value(this.balance - bounty)(address(this));
msg.sender.transfer(bounty);
} | 1 |
function Ownable() public { owner = msg.sender; }
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 0 |
function transferFrom(address from, address to, uint256 value) public pure returns (bool success){
return false;
} | 0 |
function owned() public {
owner = msg.sender;
} | 0 |
function transfer(address _to, bytes32 _value) returns (bool success) {
if (_value == 0x0) return false;
if (tokens[_value].id() != _value) return false;
if (ownedToken[_to] != 0x0) return false;
var tokenToTransfer = tokens[_value];
if (tokenToTransfer.owner != msg.sender) return false;
tokenToTransfer.owner = _... | 0 |
function timeLockAdvisor(address _target) public onlySuperAdmins validateAddress(_target) {
require(timelockedAccounts[_target] == 0);
timelockedAccounts[_target] = ADVISOR_LOCKUP_END;
emit LockedFunds(_target, ADVISOR_LOCKUP_END);
} | 0 |
function balanceOf(address _owner) external view returns (uint256 balance);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b... | 0 |
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256... | 0 |
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 ... | 0 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _to != 0x0, "Receiver can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked");
bal... | 0 |
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
} | 0 |
function setIcoAddress(address _ico) public onlyOwner {
require(_ico != address(0));
require(balanceOf(addressIco) == 0);
addressIco = _ico;
transferOwnership(_ico);
} | 0 |
constructor(ReadableI _makerDAOMedianizer) public {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
} | 0 |
function removePlot(address addr, uint id) private {
uint n = plotsOwned[addr].length;
for (uint8 i = 0; i < n; i++) {
if (plotsOwned[addr][i] == id) {
plotsOwned[addr][i] = plotsOwned[addr][n - 1];
delete plotsOwned[addr][n - 1];
plotsOwned[addr].length--;
break;
}
}
} | 0 |
function getBalance () constant noEther returns (uint256) {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) return 0;
return account.balance;
} | 0 |
constructor() internal {
owner = msg.sender;
} | 0 |
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
} | 0 |
function walletData(address _wallet) public view returns (string) {
return whitelist[_wallet].data;
} | 0 |
function getGameSettings() external view returns (
uint _recruitHeroFee,
uint _transportationFeeMultiplier,
uint _noviceDungeonId,
uint _consolationRewardsRequiredFaith,
uint _challengeFeeMultiplier,
uint _dungeonPreparationTime,
uint _trainingFeeMultiplier,
uint _equipmentTrainingFeeMultiplier,
uint _preparat... | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner ... | 0 |
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) onlyPayloadSize(4 * 32) public returns (bool success) {
if(isContract(_to)) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receive... | 0 |
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(ad... | 0 |
function deposit(address investor) onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
} | 0 |
function resetEmergencyRelease(address traderAddr) private {
if (emergencyReleaseSince[traderAddr] != 0) {
emergencyReleaseSince[traderAddr] = 0;
}
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
ERC20 public token;
uint256 private transactionNum;
uint256 public startTime;
uint256 public endTime;... | 0 |
function setFounderLock(address _address, uint256 _value, uint _round, uint256 _period) internal{
founderLockance[_address].amount = _value;
founderLockance[_address].startTime = now;
founderLockance[_address].remainRound = _round;
founderLockance[_address].totalRound = _round;
founderLockance[_address].period = _... | 0 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 initialSupply=5000000000;
uint256 MAX_CAP = 5000000000;
uint256 public totalSupply;
ma... | 0 |
function getStats() constant returns (uint32, uint32, uint32, bool) {
return (
uint32(totalContribution / 1 finney),
uint32(totalSupply / 1 finney),
uint32(totalBonusTokensIssued / 1 finney),
purchasingAllowed
);
} | 1 |
function getTime() internal returns (uint) {
return now;
} | 1 |
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (boo... | 0 |
function updatePromoter4(address _address) external onlyOwner {
require(_address != address(0x0));
promoter4 = _address;
} | 0 |
function releaseICO() external onlyOwner {
stopped = false;
stage = Stages.ICO;
} | 0 |
function ecoIssue(address _to, uint _time, uint _value) onlyOwner public
{
require(saleTime == false);
require( _time < ecoVestingTime);
uint nowTime = now;
require( nowTime > ecoVestingTimer[_time] );
uint tokens = _value * E18;
require(tokens <= ecoVestingBalances[_time]);
require(tokens > 0);
require(maxEco... | 0 |
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(this.balance);
} else {
uint256 balance = token.balanceOf(this);
require(token.transfer(reclaimer, balance));
}
} | 0 |
function invest() public payable {
assert(now >= offset && now < offset + length);
assert(collected + price <= hardCap || hardCap == 0);
require(msg.value >= price);
address investor = msg.sender;
uint tokens = msg.value / price;
uint value = tokens * price;
if (value + collected > hardCap || hardCap == 0) {
va... | 0 |
function changeDeveloper(address new_dev)
noEthSent
onlyDeveloper
{
developer=new_dev;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
require(_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function allowance(address _owner, address _spender) external constant returns (uint remaining) {
return allowed[_owner][_spender];
} | 0 |
function getCurrentlyRunningPhase()public view returns(int8){
for(uint8 i=0;i<noOfPhases;i++){
if(phases[i].startTime!=0 && now>=phases[i].startTime && phases[i].endTime == 0){
return int8(i);
}
}
return -1;
} | 0 |
constructor() public {
lock = now;
emit SetLock(0, now);
} | 0 |
constructor () internal {
_addMinter(msg.sender);
} | 0 |
function recover(bytes32 hash, bytes memory sig) public pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) ... | 0 |
function myDividends()
external
view
returns(uint256)
{
address shareholder = msg.sender;
uint256 dividendPointsDifference = totalDividendPoints.sub(shareholders[shareholder].lastDividendPoints);
return shareholders[shareholder].outstandingDividends
.add(dividendPointsDifference.mul(shareholders[shareholder].to... | 0 |
function usageFee(bytes32 _serviceName, uint256 _multiplier) public constant returns(uint fee) {
require(isValidService(_serviceName));
require(_multiplier != 0);
return 0;
} | 0 |
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
} | 0 |
function changeEndTime(uint256 _newTime) onlyOwner external {
require(endTime >= now);
endTime = _newTime;
} | 0 |
function time() public view returns (uint) {
return block.timestamp;
} | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function fetchDividendsFromP3X()
public
{
lastDividendsFetched = now;
uint256 dividends = p3xContract.dividendsOf(address(this), true);
if(dividends > 0) {
p3xContract.withdraw();
totalDividendPoints = totalDividendPoints.add(dividends.mul(POINT_MULTIPLIER) / totalSupply);
totalOutstandingDividends = totalOutst... | 0 |
function withdrawBonus() onlyBonusOwner {
if(now>finalTimestampOfBonusPeriod) {
var bonusValue = ownedBonus[msg.sender];
ownedBonus[msg.sender] = 0;
BonusWithdrawn(msg.sender, bonusValue);
msg.sender.transfer(bonusValue);
}
} | 1 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to) || isNewParent[_to]) {
if ((msg.sender==returnChildAddressForParent(_to)) || (returnChildForParentNew[_to]==msg.sender)) {
... | 1 |
function registerColor(string label, uint256 startingPrice) external onlyOwner {
Color memory _Color = Color({
label: label,
creationTime: uint64(now)
});
uint256 newColorId = colors.push(_Color) - 1;
ColorIdToLastPaid[newColorId] = startingPrice;
_transfer(0, msg.sender, newColorId);
} | 1 |
function authorized_recordFailedOldOwnerTransfer(address _oldOwner) external payable requireAuthorizedLogicContract {
addressToFailedOldOwnerTransferAmount[_oldOwner] += msg.value;
totalFailedOldOwnerTransferAmounts += msg.value;
} | 0 |
function refundable(bytes32 _swapID) external view returns (bool) {
return (now >= swaps[_swapID].timelock && swapStates[_swapID] == States.OPEN);
} | 0 |
function getCurrent() internal returns (uint256) {
return now;
} | 1 |
function withdrawEther(address traderAddr, address payable withdrawalAddr, uint amount) external
onlyActive()
onlyApprovedExchange(traderAddr) {
deductBalance(0, traderAddr, amount);
resetEmergencyRelease(traderAddr);
emit Withdrawal(0, traderAddr, withdrawalAddr, amount);
withdrawalAddr.transfer(amount);
} | 0 |
function hodl(address _beneficiary, uint256 _id, uint256 _value, uint256 _months) external {
require(_beneficiary != address(0));
require(_id > 0);
address _creator = msg.sender;
Item storage item = items[_creator][_id];
require(item.id != _id);
items[_creator][_id] = Item(_id, _creator, _beneficiary, false);
pu... | 0 |
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _}
function DaoChallenge () {
challengeOwner = msg.sender;
} | 0 |
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
require (_value >= minContribution);
require (!isFinalized);
uint256 tokens = safeMult(_value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(total... | 1 |
function Escrow() {
owner = msg.sender;
} | 0 |
function transferTokensLeftOver() internal {
require(!remainingTransfered);
require(maxTokensRaised > tokensRaised);
remainingTransfered = true;
uint256 remainingTokens = maxTokensRaised.sub(tokensRaised);
token.distributeCrowdsaleTokens(msg.sender, remainingTokens);
} | 0 |
function setEndDate(uint256 _endTime)
external onlyOwner whenNotPaused
{
require(now <= _endTime);
require(startTime < _endTime);
endTime = _endTime;
} | 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 lock(address _address) public onlyOwner {
lockedAddress[_address] = true;
} | 0 |
function pay(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
payable
{
require(msg.value > 0);
require(msg.value == _value);
require(msg.value > _commission);
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, msg.value, _commission);
verifyDea... | 0 |
function _releasableAmount(IERC20 token) private view returns (uint256) {
return _vestedAmount(token).sub(_released[address(token)]);
} | 0 |
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spend... | 0 |
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract TokenHolder is ITokenHolder, Owned {
function TokenHolder() {
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath::sub: Integer underflow");
uint256 c = a - b;
return c;
} | 0 |
function destroy() onlyOwner public {
selfdestruct(owner);
} | 0 |
function nonceOf(address _addr) public view returns (uint256 nonce){
return _nonces[_addr];
} | 0 |
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address customerAddress, bool includeReferralBonus) external view returns(uint256);
function withdraw() external;
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
re... | 0 |
function _recordFirstClaimTimestamp(uint256 _cardId) internal {
cardIdToFirstClaimTimestamp[_cardId] = uint128(now);
} | 0 |
function setReleaseType(address _target, ReleaseType _type) public onlyOwner {
require(_target != address(0));
_accountType[_target] = _type;
} | 0 |
function ToLend() public payable
{
Certificates[msg.sender].Time = now;
Certificates[msg.sender].Invested += msg.value;
Deposited(msg.sender, msg.value);
} | 1 |
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.