function string | label int64 |
|---|---|
function _updateNextWithdrawalTime(uint256 oldWithdrawal) internal view returns (uint256)
{
uint currentTimestamp = block.timestamp;
require(oldWithdrawal <= currentTimestamp, "You need to wait the next withdrawal period");
if (oldWithdrawal == 0)
{
return _timeShiftPeriod.add(currentTimestamp);
}
return oldWit... | 0 |
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
} | 0 |
function random(uint64 upper) public returns (uint64 randomNumber) {
_seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
return _seed % upper;
} | 1 |
function checkRole(address addr, string roleName)
view
public
{
roles[roleName].check(addr);
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
bool withinPeriod = now >= presaleStartTime && now <= endTime;
bool atLeastMinimumAmount = false;
if(block.timestamp <= startTime) {
require(_weiAmount.add(weiRaised.add(privateContribution)) <= presaleFundingGoal);
atLeastMinimumAm... | 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 increaseApproval(address _spender, uint _addedValue) public 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 payFee(bytes32 serviceName, uint256 multiplier, address client) public returns(bool paid);
function usageFee(bytes32 serviceName, uint256 multiplier) public constant returns(uint fee);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwn... | 0 |
function burn(uint256 _value) public onlyOwner returns (bool) {
require(balances[msg.sender] >= _value);
require(maxBurnThreshold >= _value);
require(maxDestroyThreshold >= destroyedToken.add(_value));
balances[msg.sender] = balances[msg.sender].sub(_value);
totalToken = totalToken.sub(_value);
destroyedToken = d... | 0 |
modifier onlyPayloadSize(uint256 _size) {
require(msg.data.length >= _size + 4);
_;
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
function setCoinPrice(uint256 newPriceInWei) public returns(uint256 oldPriceInWei){
require(msg.sender==owner);
uint256 _old=coinPriceInWei;
coinPriceInWei=newPriceInWei;
return _old;
} | 0 |
function removeMinter(address _minter) external onlyOwner returns (bool) {
require(_minter != address(0));
_minters[_minter] = false;
return true;
} | 0 |
function sha(uint128 wager) constant private returns(uint256)
{
return uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, wager));
} | 1 |
function transferOwnership(address newOwner)
public;
}
contract IAuthorizable is
IOwnable
{
function addAuthorizedAddress(address target)
external;
function removeAuthorizedAddress(address target)
external;
function removeAuthorizedAddressAtIndex(
address target,
uint256 index
)
external;
function getAuthor... | 0 |
function pause() external onlyOwner ifNotPaused {
paused = true;
} | 0 |
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
... | 0 |
function buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
send... | 1 |
function advisorIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advisorVestingTime);
uint nowTime = now;
require( nowTime > advVestingTimer[_time] );
uint tokens = advisorVestingSupply;
require(tokens == advVestingBalances[_time]);
require(maxAdvisorSupply >= token... | 0 |
modifier onlyAdmin() {
require(addressIsAdmin[msg.sender] || msg.sender == owner);
_;
} | 0 |
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event... | 0 |
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns ... | 0 |
function isTransferable() private view returns (bool)
{
if(tokenLock == false)
{
return true;
}
else if(msg.sender == owner1 || msg.sender == owner2)
{
return true;
}
return false;
} | 0 |
modifier ownerOnly() {
require(msg.sender == owner);
_;
} | 0 |
function _vestedAmount(IERC20 token) private view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[address(token)]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration) || _revoked[address(toke... | 0 |
function setFinalizeAgent(FinalizeAgent addr) internal {
require(address(addr) == 0 || addr.isFinalizeAgent());
finalizeAgent = addr;
require(isFinalizerSane());
} | 0 |
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
constructor(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function enableWhitelist() public onlyOwner {
whitelistEnabled = true;
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
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);
... | 0 |
function getNow() internal constant returns (uint) {
return now;
} | 1 |
function store(bytes32 hash) external {
assert(msg.sender == owner);
assert(hashToTimestamp[hash] <= 0);
hashToTimestamp[hash] = block.timestamp;
hashToNumber[hash] = block.number;
emit Hashed(hash);
} | 0 |
function checkoutCart(string _firstname) payable returns (uint)
{
if( msg.value < subtotal[msg.sender] ){ revert(); }
for( uint x = 0; x < cart[msg.sender].length; x++ )
{
if( shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].quantity > 0 )
{
NewSandwichTicket( _firstname, msg.sender,
shopSandwich[ cart[msg.... | 1 |
function updateEndTime(uint256 newEnd) onlyOwner {
endTime = newEnd;
} | 0 |
function SocialActivityToken() public
{
owner = msg.sender;
balances[owner] = 350000000 * (uint256(10) ** decimals);
balances[address(this)] = 650000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function app... | 0 |
function Lockable()
public
{
creationTime = now;
tokenTransfer = false;
owner = msg.sender;
} | 1 |
function setOwner(address _new)
public
onlyOwner
{
require(_new != address(0));
owner = _new;
emit NewOwner(owner, _new);
} | 0 |
function KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = ... | 0 |
function getCurrentTime() internal constant returns (uint) {
return now;
} | 1 |
function getRandom() private returns (uint) {
return (uint(sha3(block.timestamp + block.number + block.gaslimit + block.difficulty + msg.gas + uint(msg.sender) + uint(block.coinbase))) % totalTickets) + 1;
} | 1 |
function myAddress () external view returns(address myadddress) {
myadddress = msg.sender;
} | 0 |
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
} | 0 |
modifier isOwer() {
require(msg.sender == owner_, "you need owner auth");
_;
} | 0 |
function receiveTokens(uint256 tokens) {
DaoAccount sender = DaoAccount(msg.sender);
if (!AbstractDaoChallenge(daoChallenge).isMember(sender, sender.getOwnerAddress())) throw;
if (tokens > sender.getTokenBalance()) throw;
if (tokenBalance + tokens < tokenBalance) throw;
tokenBalance += tokens;
} | 0 |
function releaseLockedTokensFor(address _owner) public {
TokenTimelock(lockOf[_owner]).release();
} | 0 |
modifier onlyUnlocked() {
uint nowtime = block.timestamp;
uint futuretime = 1550537591;
if(nowtime > futuretime) {
_;
} else {
require(!lockedAddress[msg.sender]);
_;
}
} | 0 |
function OTPPAY() public
{
owner = msg.sender;
balances[owner] = 319000000 * 10 **18;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
modifier onlyOwner() {
require(msg.sender == owner,"Ownable: caller is not owner.");
_;
} | 0 |
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
uint256 c = _a - _b;
return c;
} | 0 |
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, this.balance);
} | 0 |
function time() constant returns (uint) {
return now;
} | 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 publicSaleIssue(address _to) onlyOwner public
{
require(tokenIssuedSale == privateSaleSupply);
uint tokens = publicSaleSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
} | 0 |
function invest(address to) onlyActive public payable {
uint amount = msg.value;
uint tokenAmount = getCurrentBonus().mul(amount).mul(10 ** decimals / 100).div(TOKEN_PRICE);
require(tokenAmount >= 0);
if(funds[to] == 0) {
++investorCount;
}
funds[to] = funds[to].add(amount);
totalFunds = totalFunds.add(amount);... | 0 |
function updatePrice(uint256 price) public onlyOwner {
require(price > 0);
priceHistory[updatedTime] = ETHUSD;
ETHUSD = price;
updatedTime = block.timestamp;
emit PriceUpdated(ETHUSD);
} | 0 |
function transferFrom(address from, address to, uint value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.transferFrom(from, to, value);
} | 0 |
function getTransformState() public constant returns(TransformState) {
if(address(transformAgent) == 0x00) return TransformState.WaitingForAgent;
else if(totalTransformedTokens == 0) return TransformState.ReadyToTransform;
else return TransformState.Transforming;
} | 0 |
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
} | 0 |
function allowance(address _owner, address _spender) constant public returns (uint256) {
return c_approvals[_owner][_spender];
} | 0 |
function totalSupply() public view returns (uint256);
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 u... | 0 |
function CentraAsiaWhiteList() {
owner = msg.sender;
operation = 0;
} | 1 |
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
emit Mint(to, value);
return true;
} | 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) internal balances;... | 0 |
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 balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256)... | 0 |
function calculate_fee(uint8 class, bool repellent) internal view returns(uint){
if(repellent){
return PRICE_CLASS[class] * (100 + PRICE_REPELLENT) / 100;
}else{
return PRICE_CLASS[class];
}
} | 0 |
function approve(address _spender, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
_allowance[msg.sender][_spender] = add(_allowance[msg.sender][_spender], _value);
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function getStats() constant returns (uint256, uint256, bool) {
return (totalContribution, totalSupply, purchasingAllowed);
} | 1 |
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
} | 0 |
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
} | 0 |
function auditorHasStaked(uint _id, address _auditor) public view returns(bool) {
return auditors[_auditor].stakedInAudit[_id];
} | 0 |
function mint0(address _owner, uint256 _amount) onlyOwner {
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = uint32(block.timestamp);
Transfer(0, _owner, _amount);
} | 1 |
function isEthereumBased(address _tokenAddress) private pure returns (bool) {
return (_tokenAddress != address(0x0));
} | 0 |
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
} | 0 |
function revocable() public view returns (bool) {
return _revocable;
} | 0 |
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool c... | 1 |
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
} | 0 |
function hasSaleEndTimeCome() public view returns(bool) {
return (block.timestamp > saleEndTime);
} | 0 |
function KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = ... | 0 |
function myHoldAgeTimestamp() external view returns (uint256) {
return _holdAgeTimestamp(msg.sender);
} | 0 |
function transferFrom(address _from, address _to, uint _value) public validateAddress(_to) isNotTimeLockedFrom(_from) isNotFrozenFrom(_from, _to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
modifier whenCrowdsaleAlive() {
require(isActive());
_;
} | 0 |
function setCeilingStrategy(CeilingStrategy addr) internal {
require(addr.isCeilingStrategy());
ceilingStrategy = addr;
} | 0 |
function timestamp(bytes32 hash) public returns (bool) {
if (timestamps[hash].timestamp != 0) {
return false;
}
timestamps[hash].timestamp = block.timestamp;
timestamps[hash].sender = msg.sender;
return true;
} | 1 |
function addDocHash(bytes32 hash) public ownerOnly {
Record memory newRecord = Record(block.timestamp, block.number);
docHashes[hash] = newRecord;
} | 0 |
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
} | 0 |
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
} | 0 |
function initProlongationVoting() public;
function initTapChangeVoting(uint8 newPercent) public;
function inProgress() public view returns (bool);
function yes(address _address, uint _votes) public;
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
funct... | 0 |
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0));
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiary;
_revocable = revocable;
_du... | 0 |
function prepareContinuousPurchase() internal {
uint256 timestamp = block.timestamp;
uint256 bucket = timestamp - (timestamp % BUCKET_SIZE);
if (bucket > lastBucket) {
lastBucket = bucket;
bucketAmount = 0;
}
} | 1 |
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
return true;
}
return false;
}
} | 1 |
function sendWingsRewardsOnce() public onlyOwner canBeCalledOnce("sendWingsRewards") {
require(isFinishedSuccessfully());
uint256 ethReward = 0;
uint256 tokenReward = 0;
(ethReward, tokenReward) = bridge.calculateRewards();
if (ethReward > 0) {
bridge.transfer(ethReward);
}
if (tokenReward > 0) {
token.sell(br... | 0 |
function max(uint256 a, uint256 b) private pure returns (uint256) {
return a > b ? a : b;
} | 0 |
function undo() public stoppable {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
} | 1 |
function DIGI(){
totalSupply=980000000000;
owner = msg.sender;
balances[msg.sender] = (980000000000);
twoWeeksBonusTime=now + 2 * 1 weeks;
thirdWeekBonusTime=twoWeeksBonusTime+1 * 1 weeks;
fourthWeekBonusTime=thirdWeekBonusTime+1 * 1 weeks;
deadLine=fourthWeekBonusTime+1 *1 weeks;
etherRaised=0;
} | 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 transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x313508... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.