function string | label int64 |
|---|---|
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success)
{
uint oldValue = allowance[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowance[msg.sender][_spender] = 0;
} else {
allowance[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval... | 0 |
function next_id() internal returns (uint) {
last_offer_id++; return last_offer_id;
} | 0 |
function ownerClawback() external onlyOwner {
require(totalFunding < PRESALE_MINIMUM_FUNDING);
require(now >= OWNER_CLAWBACK_DATE);
owner.transfer(this.balance);
} | 0 |
function declineKyc(address participant) external onlyOwnerOrAuditor {
kycStatus[participant] = KycState.Declined;
LogKycDecline(participant, pendingAmountOfEth, now);
uint256 pendingAmountOfEth = pendingContributionOf[participant];
if (pendingAmountOfEth > 0) {
resetPendingContribution(participant);
participant.... | 0 |
function setContract(string intervener1, string intervener2){
date = now;
name1 = intervener1;
name2 = intervener2;
} | 0 |
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 FallbackFailer {... | 0 |
function calculateTokensPerTier(uint256 weiPaid, uint256 tierSelected)
internal constant returns(uint256 calculatedTokens)
{
require(weiPaid > 0);
require(tierSelected >= 1 && tierSelected <= 4);
if (tierSelected == 1) {
calculatedTokens = weiPaid.mul(rate);
} else if (tierSelected == 2) {
calculatedTokens = we... | 0 |
function emergencyClawbackEther(uint256 value) external onlyOwnerOrMultisig {
require(contractFailed);
require(contractRefundStarted);
require(contractRefundFinished);
require(value > 0);
require(value <= address(this).balance);
msg.sender.transfer(value);
} | 0 |
function ownerOf(uint256 assetId) public view returns (address);
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acc... | 0 |
function StreamityEscrow(address streamityContract) public {
owner = msg.sender;
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
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 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal... | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
} | 0 |
function addOversight(address addr) external multisig(sha3(msg.data)) {
activateOversightAddress(addr);
oversightAddresses[addr] = true;
} | 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 CatHODL () public {
releaseDate = now + 1 years;
} | 0 |
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-... | 0 |
function create() payable whenNotClosed whenNotPaused public returns (bool success) {
require(msg.value > 0);
require(now >= preIcoOpeningTime);
uint256 weiToParticipate = msg.value;
adjustPhaseBasedOnTime();
if (phase != Phases.AfterIco || weiToParticipate < (0.01 * 10**18)) {
Rates memory rates = getRates();
u... | 0 |
function finalize() external {
if (!funding) throw;
if ((block.number <= fundingEndBlock ||
totalTokens < tokenCreationMin) &&
totalTokens < tokenCreationCap) throw;
funding = false;
uint256 percentOfTotal = 10;
uint256 additionalTokens =
totalTokens * percentOfTotal / (100 - percentOfTotal);
totalTokens += ad... | 0 |
function getTime() constant returns (uint) {
return block.timestamp;
} | 0 |
function endMinting() onlyOwner {
transferOwnership(address(0xdead));
EndMinting(block.timestamp);
} | 1 |
function NihilistCoin() {
balances[msg.sender] = 100000000000000000000000000;
totalSupply = 100000000000000000000000000;
name = "NihilistCoin";
decimals = 18;
symbol = "NULL";
unitsOneEthCanBuy = 10000;
fundsWallet = msg.sender;
saleEnd = 1522540800;
} | 1 |
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) public balances;
function transfer(address _to, uint256 _value) public returns (b... | 0 |
function approve(address spender, uint tokens) public returns (bool success) {
return data.approve(spender, tokens);
} | 0 |
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
} | 0 |
function burn(uint amount) external onlyMerchant returns (bool) {
string memory btcDepositAddress = merchantBtcDepositAddress[msg.sender];
require(!isEmptyString(btcDepositAddress), "merchant btc deposit address was not set");
uint nonce = burnRequests.length;
uint timestamp = getTimestamp();
string memory btcTxid... | 0 |
function confirmMintRequest(bytes32 requestHash) external onlyCustodian returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingMintRequest(requestHash);
mintRequests[nonce].status = RequestStatus.APPROVED;
require(controller.mint(request.requester, request.amount), "mint failed");
emit ... | 0 |
function plus(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
} | 0 |
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMa... | 0 |
function getState() public constant returns (State) {
if (now < startsAt) return State.PreFunding;
else if (now <= endsAt) return State.Funding;
else if (now > endsAt) return State.Closed;
} | 0 |
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
Insufficient... | 0 |
function sellKebabs() public{
require(initialized);
uint256 hasKebabs=getMyKebabs();
uint256 kebabValue=calculateKebabSell(hasKebabs);
uint256 fee=calculatePercentage(kebabValue,10);
workingKebaber[msg.sender] = SafeMath.div(workingKebaber[msg.sender],2);
claimedKebabs[msg.sender]=0;
lastKebab[msg.sender]=now;
... | 0 |
function finalization() internal {
} | 0 |
function ownerDeclareRefundFinish() external onlyOwner {
require(contractFailed);
require(contractRefundStarted);
require(!contractRefundFinished);
contractRefundFinished = true;
} | 0 |
function createAgreement(IERC20 token, address recipient, uint256 totalAmount, uint48 duration, uint48 start) external {
require(duration > 0, "Duration must be greater than zero");
require(totalAmount > 0, "Total Amount must be greater than zero");
require(start > 0, "Start must be greater than zero");
require(tok... | 0 |
function decreaseAllowance(address _spender, uint256 _subtractedValue) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked() returns (bool)
{
return super.decreaseAllowance(_spender, _subtractedValue);
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
} | 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 ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function DinosaurFarmer2() public{
ceoAddress=msg.sender;
} | 0 |
function proxyClaimTokens(address receiverAddress)
public
atStage(Stages.AuctionEnded)
returns (bool)
{
require(now > finalizedTime + TOKEN_CLAIM_WAITING_PERIOD);
require(receiverAddress != 0x0);
if (bids[receiverAddress] == 0) {
return false;
}
uint num = (tokenMultiplier * bids[receiverAddress]) / finalPric... | 0 |
function getMessage () constant returns (string retVal) {
return message;
} | 1 |
function TimeNow() public constant returns(uint256)
{
return now;
} | 1 |
function burnFrom(address from, uint256 value) public returns (bool) {
_burnFrom(from, value);
return true;
} | 0 |
function getTime() internal view returns(uint256) {
return now;
} | 1 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
} | 0 |
function setMintMaster(address newMintMaster)
returns (bool ok)
{
require(msg.sender == mintMaster);
address oldMintMaster = mintMaster;
mintMaster = newMintMaster;
LogSetMintMaster(oldMintMaster, mintMaster);
return true;
} | 0 |
function batchCancelOrders(LibOrder.Order[] memory orders)
public
nonReentrant
{
uint256 ordersLength = orders.length;
for (uint256 i = 0; i != ordersLength; i++) {
cancelOrderInternal(orders[i]);
}
} | 0 |
function release(uint256 timestamp, uint256 sysAmount) public onlyOperator returns(uint256 _actualRelease) {
require(timestamp >= createTime && timestamp <= block.timestamp);
require(!checkIsReleaseRecordExist(timestamp));
updateReleaseAmount(timestamp);
require(sysAmount <= releaseAmountPerDay.mul(4).div(5));
req... | 0 |
function enter_next_race(uint block_finish_last, uint8 class, uint8 variant, bool repellent) external payable{
cleanup(block_finish_last);
if(races[race_number].block_finish != 0 || race_number == 0){
declare_race(class,variant,repellent);
}else{
enter_race(class,variant,repellent);
}
} | 0 |
function getLockedAmount_contributors(address _contributor)
public
constant
returns (uint256)
{
uint256 countdownDate = contributors_countdownDate[_contributor];
uint256 lockedAmt = contributors_locked[_contributor];
if (now <= countdownDate + 1 hours) {return lockedAmt;}
if (now <= countdownDate + 2 hours) {re... | 0 |
function addApproval(address _spender, uint _addedValue) public
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
allowed[msg.sender][_spender] = oldValue.add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function getBlockTimestamp() returns (uint256) {
return block.timestamp;
} | 1 |
function increaseApproval (address _spender, uint _addedValue) public whenNotPaused
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function transfer(address _to, uint256 _value) public canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function pause() public onlyOwner {
require(!paused(), "Pausable: Already paused.");
super._pause();
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(... | 0 |
function transferFrom(address _from, address _to, uint256 _value) ifUnlocked public returns (bool) {
return super.transferFrom(_from, _to, _value);
} | 0 |
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) {
... | 0 |
modifier notLessThan2Eth() {
require(investedAmountOf[msg.sender].add(msg.value) >= 2 * (10**18));
_;
} | 0 |
function mintInflation(address _thePool, uint256 _reward)
external
onlyProofOfPerformance
minimumRigo(_thePool)
timeAtLeast(_thePool)
returns (bool)
{
performers[_thePool].startTime = now;
performers[_thePool].endTime = now + period;
++performers[_thePool].epoch;
uint256 reward = _reward * 95 / 100;
uint256 ... | 0 |
function updateWallet(address _wallet, string _data) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
} | 0 |
function approve(address _spender, uint256 _value) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function start(uint endAt_) public onlyOwner {
require(endAt_ > block.timestamp && state == State.Inactive);
endAt = endAt_;
startAt = block.timestamp;
state = State.Active;
emit ICOStarted(endAt, lowCapWei, hardCapWei, lowCapTxWei, hardCapTxWei);
} | 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 onlyAfter(uint _time) {
require(now >= _time);
_;
} | 0 |
function endSale() {
require(owner == msg.sender);
require(!locked);
snapshotTimestamp = block.timestamp;
balanceAtSnapshot = Token(dvipAddress).balanceOf(saleAddress);
locked = true;
} | 1 |
function getWhitelist() view public returns (address[]) {
return WhitelistsAccts;
} | 0 |
function transferAllAndCall(address _to, bytes _extraData) public returns (bool success){
return transferAndCall(_to, balanceOf[msg.sender], _extraData);
} | 0 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, ... | 0 |
function _transfer(address _to, uint256 _value, bytes _data) private returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
} | 0 |
function _mint(address account, uint256 amount) internal {
require(account != 0);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
} | 0 |
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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (add... | 0 |
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
} | 1 |
function hasEnded() public constant returns (bool) {
return now > endTime;
} | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function setLockup_jiedians(address _jiedian, uint256 _value, uint256 _jiedianDate)
public
onlyOwner
{
require(_jiedian != address(0));
jiedians_locked[_jiedian] = _value;
jiedians_jiedianDate[_jiedian] = _jiedianDate;
UpdatedLockingState("jiedian", _jiedian, _value, _jiedianDate);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value... | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
return transferFrom(_from, _to, bytes32(_value));
} | 0 |
function Marketplace(address _acceptedToken, address _nonFungibleRegistry) public {
acceptedToken = ERC20Interface(_acceptedToken);
nonFungibleRegistry = ERC721Interface(_nonFungibleRegistry);
} | 0 |
function updateDuration(uint256 _newP2Start) external onlyOwner {
require(isCrowdSaleSetup
&& !(p2_start == _newP2Start)
&& !(_newP2Start > p1_start + p1_duration + 30 hours)
&& (now < p2_start)
&& (fundingStartTime + p1_duration < _newP2Start));
p2_start = _newP2Start;
fundingEndTime = p2_start.add(4 hours);
} | 0 |
function purchase(uint id, string metadata, bool forSale, uint newPrice)
validID(id) tradingIsEnabled payable returns(bool)
{
LunarPlot plot = plots[id];
if (isUnowned(id)) {
require(msg.value >= initialPrice);
} else {
require(plot.forSale && msg.value >= plot.price);
}
if (plot.owner != 0x0) {
uint fee = pl... | 0 |
function PreSaleToken() public {
owner = msg.sender;
} | 0 |
function allowance(address _owner, address _spender) view public returns (uint) {
return approvals[_owner][_spender];} | 0 |
function notifySale(uint256 _ethAmount, uint256 _tokensAmount) public
hasBeenStarted()
hasntStopped()
whenCrowdsaleAlive()
onlyCrowdsale()
{
totalCollected = totalCollected.add(_ethAmount);
totalSold = totalSold.add(_tokensAmount);
} | 0 |
function hasClosed() public view returns (bool) {
for(uint i = 0; i < MAX_FUND_SIZE; ++i)
{
if(openingTimeArray[i] <= now && now <= closingTimeArray[i])
{
return false;
}
}
return true;
} | 0 |
function transfer(address _to, uint256 _amount) public returns (bool success) {
if (speedBump)
{
require (_amount <= transferMaxAmount, "Speed bump activated, amount exceeded");
require (now > (lastTransfer + transferWait), "Speed bump activated, frequency exceeded");
lastTransfer = now;
}
uint256 fee = calcTran... | 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 allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) ... | 0 |
function addOwner(address sender, Proxy identity, address newOwner) public
onlyAuthorized
onlyOlderOwner(identity, sender)
rateLimited(identity, sender)
{
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now - userTimeLock;
LogOwnerAdded(identity, newOwner, sender);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
function getCooldown(uint16 speed) external view returns (uint64){
return uint64(now + cooldowns[speed - 1]);
} | 1 |
function releaseReserveTokens() public {
reserveTimelock.release();
} | 0 |
function weiAllowedToReceive(uint tentativeAmount, uint weiRaised, uint weiInvestedBySender, uint weiFundingCap) public constant returns (uint) {
uint totalOfSender = tentativeAmount.add(weiInvestedBySender);
if (totalOfSender > weiLimitPerAddress) tentativeAmount = weiLimitPerAddress.sub(weiInvestedBySender);
if (w... | 0 |
function apLockUp(address _to) onlyOwner public
{
require(tokenLock == false);
require(saleTime == false);
uint time = now;
uint unlockTokens = 0;
if( (time >= apLock_1) && (ap1[_to] > 0) )
{
balances[_to] = balances[_to].add(ap1[_to]);
unlockTokens = unlockTokens.add(ap1[_to]);
ap1[_to] = 0;
}
if( (time >=... | 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 getClaim(address issuer, address subject, bytes32 key) public constant returns(bytes32) {
return registry[issuer][subject][key];
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(frozenAccounts[msg.sender] < now);
return super.transfer(_to, _value);
} | 0 |
function minus(uint a, uint b) public pure returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function getFreeShrimp() public{
require(initialized);
require(hatcheryShrimp[msg.sender]==0);
lastHatch[msg.sender]=now;
hatcheryShrimp[msg.sender]=STARTING_SHRIMP;
} | 0 |
function getCurrentMilestone() private constant returns (Milestone) {
uint i;
uint price;
for(i=0; i<milestones.length; i++) {
if(now < milestones[i].time) {
return milestones[i-1];
}
}
} | 1 |
function getTicket (address _attendee) payable public {
require(now >= startTime && msg.value >= FEE && userId[_attendee] == 0);
userAmount ++;
require(userAmount <= maxAttendees);
userId[_attendee] = userAmount;
id2Addr[userAmount] = _attendee;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.