function string | label int64 |
|---|---|
function freeze(address _account) public onlyOwner {
freeze(_account, 0);
} | 0 |
function boostCloneMarket(uint _eth) public payable {
require(initialized);
emit MarketBoost(_eth);
} | 0 |
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256)
{
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
} | 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... | 0 |
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 {
... | 0 |
function getLockedAmount_investors(address _investor)
public
constant
returns (uint256)
{
uint256 delieveryDate = investors_deliveryDate[_investor];
uint256 lockedAmt = investors_locked[_investor];
if (now <= delieveryDate) {return lockedAmt;}
if (now <= delieveryDate + 1 hours) {return lockedAmt.mul(2).div(3);... | 0 |
function doPurchase() payable {
require(now >= startICO && now < endPostICO);
require(msg.value > 0);
uint sum = msg.value;
uint tokensAmount;
if(now < endICO){
tokensAmount = sum.mul(ETHUSD).div(tokenIcoUsdCentPrice).div(10000000000);
} else {
tokensAmount = sum.mul(ETHUSD).div(tokenPostIcoUsdCentPrice).div(10... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
if(msg.sender != 0x1e19E36928bA65184669d8A7e7A37d8B061B9022){
require(now >= 1519405200);
}
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] ... | 1 |
function transfer(address _to, uint256 _value) public returns (bool)
{
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(now > _tradeableDate || _to == POOL || msg.sender == POOL);
if (_to == CONVERT_ADDRESS)
{
address burner = msg.sender;
balances[burner] = balances[burner].sub(_valu... | 1 |
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 va... | 0 |
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowa... | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
icoRunningStatus = false;
uint256 x = balances[address(this)];
balances[owner] = (balances[owner]).add( balances[address(this)]);
balances[address(this)] = 0;
emit Transfer(address(this), owner , x);
} | 0 |
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
} | 0 |
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(RR.transfer(msg.sender, transferAllocation));
} | 0 |
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
} | 0 |
function voteSuicide(address beneficiary) multisig(sha3(msg.data)) {
selfdestruct(beneficiary);
} | 0 |
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
} | 1 |
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 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 start() onlyOwner public {
pauesed = false;
} | 0 |
function changeRigoblockAddress(address _newAddress) external;
function balanceOf(address _who) external view returns (uint256);
}
interface Authority {
event AuthoritySet(address indexed authority);
event WhitelisterSet(address indexed whitelister);
event WhitelistedUser(address indexed target, bool approved);
ev... | 0 |
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
} | 0 |
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
} | 0 |
function transfer(address _to, uint256 _value) public ReleaseTimeTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function _updatePurchasingState(address _beneficiary, uint _weiAmount, uint256 _tokenAmount) internal {}
function _preValidatePurchase(address _beneficiary, uint _weiAmount, uint256 _tokenAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
} | 0 |
function stop()
public
{
assert(now > timeTransferbleUntil);
stopped = true;
LogStop();
} | 1 |
function buyTo(address participant) public payable onlyWhitelist {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() >= fundingStartBlock && currentBlock() < fundingEndBlock);
uint256 baseAmountTokens = safeMul(msg.value, currentPrice.numerator);
uint256... | 0 |
function _transfer(address to, uint256 value) internal {
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
} | 0 |
function getRunDetails(uint _heroId) external view returns (
uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState
) {
uint genes;
address owner;
(,,, genes, owner,,) = ... | 0 |
modifier canTransfer(address _sender, uint _value) {
require(!transfersAreLocked);
require(lockUntil[_sender] < now);
_;
} | 1 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
uint256 _value = msg.value;
uint256 tokens = calculate(_value);
uint256 bonusTokens = calculate(getBonus(_value));
lockBonus(beneficiary, bonusTokens);
uint256 _totalTokens = tokens.add(bonusTokens);
require(isValidPurch... | 0 |
function setPriceRate(uint256 newPrice) public onlyOwner {
ratePerWei = newPrice;
} | 0 |
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (resul... | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function destroy(bytes32 _id) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
var tokenToDestroy = tokens[_id];
ownedToken[tokenToDestroy.owner] = 0x0;
tokenToDestroy.identity = '';
tokenToDestroy.owner = 0x0;
Destroy(_id);
numTokens -= 1;
return true;
} | 0 |
constructor () public {
_registerInterface(_INTERFACE_ID_ERC721);
_qForm = "FormSI060719 :: freeAssociationAndResponse :: ";
_qSection.push("Section 0-2b :: ");
_qSection.push("Section2-TINA :: ");
_qSection.push("Section2b-WS :: ");
_theFormSI060719.push("When we ask ourselves \"How are we?\" :: we really want t... | 0 |
function refund() external onlyOwner {
require(now > chronus.starting_time + chronus.race_duration);
require((chronus.betting_open && !chronus.race_start)
|| (chronus.race_start && !chronus.race_end));
chronus.voided_bet = true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
bettingControllerInst... | 0 |
function release() public;
}
contract IOwnable {
function isOwner(address who)
public view returns(bool);
function _isOwner(address)
internal view returns(bool);
}
contract SingleOwner is IOwnable {
address public owner;
constructor(
address _owner
)
internal
{
require(_owner != address(0), 'owner_req');
ow... | 0 |
function addTip(address _from, bytes32 _to, uint _tip) public onlyOwners {
tips[_from][_to] += _tip;
balances[_to] += _tip;
lastTip[_from][_to] = now;
} | 1 |
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
} | 0 |
function setTreasuryBalance(uint256 amount) onlyOwnerUnlocked {
treasuryBalance = amount;
} | 0 |
function transfer(address _to, uint256 _amount) public returns (bool) {
_transfer(msg.sender, _to, _amount);
return true;
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decima... | 0 |
function Squares(IScoreOracle _oracle, address _developer) public {
oracle = _oracle;
developer = _developer;
} | 0 |
function transfer(address _to, uint256 _value) whenNotPaused returns (bool success) {
require(_to!=0x0);
require(_value>0);
if (balances[msg.sender] >= _value) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
} | 0 |
function transfer(address dst, uint wad) public returns (bool) {
require (now >= releaseTime);
return super.transfer(dst, wad);
} | 1 |
function fulfillBounty(uint _bountyId, string _data)
public
validateBountyArrayIndex(_bountyId)
validateNotTooManyFulfillments(_bountyId)
isAtStage(_bountyId, BountyStages.Active)
isBeforeDeadline(_bountyId)
notIssuerOrArbiter(_bountyId)
{
fulfillments[_bountyId].push(Fulfillment(false, msg.sender, _data));
Bo... | 0 |
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
} | 1 |
function ownerWithdrawParsecs(uint256 value) external onlyOwner {
require(contractFinished);
uint256 parsecBalance = parsecToken.balanceOf(this);
uint256 maxAmountToWithdraw = parsecBalance.sub(pendingParsecs);
require(maxAmountToWithdraw > 0);
require(maxAmountToWithdraw <= parsecBalance);
require(value > 0);
r... | 0 |
function emergencyRestart() external onlyOwner _contractUp {
require(ifEmergencyStop);
ifEmergencyStop = false;
emit SaleRestarted(msg.sender, now);
} | 0 |
function isCrowdsaleFull(uint _weiRaised, uint _weiFundingCap) public constant returns (bool);
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;... | 0 |
function allowance(address approver, 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 buyTo(address participant) public payable onlyWhitelist {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() >= fundingStartBlock && currentBlock() < fundingEndBlock);
uint256 tokensToBuy = safeMul(msg.value, currentPrice.numerator) / (1 ether);
... | 0 |
function _transfer(address from, address to, uint256 value) internal {
require(value <= balanceOf(from));
require(to != address(0));
_spentBalance[from] = _spentBalance[from].add(value);
_totalBalance[to] = _totalBalance[to].add(value);
emit Transfer(from, to, value);
} | 0 |
function setTrustAddress(address _trust) public onlyOwner {
require(_trust != address(0));
trust = _trust;
} | 0 |
function setProofOfPerformance(address _pop)
external
onlyRigoblockDao
{
proofOfPerformance = _pop;
} | 0 |
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
} | 0 |
function balanceOf(address _address) constant returns(uint) {
return (vesting.getReceiverVesting(_address, assetProxy) + assetProxy.balanceOf(_address));
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
modifier canTransfer(address _sender, uint256 _value) {
require(_sender != address(0));
require(
(free_transfer) ||
canTransferBefore(_sender) ||
canTransferIfLocked(_sender, _value)
);
_;
} | 0 |
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * 5000;
if(now < startTime + 9*24*60* 1 minutes){
tokens += (tokens * 40) / 100;
if(tokensSold>14000000*10**18) throw;
}else if(now < startTime + 1... | 0 |
function _validDelegation(Delegation d) internal pure returns(bool) {
return d.setAtBlock > 0 && d.delegatee != address(0);
} | 0 |
function tokensale(address recipient) public payable {
require(recipient != 0x0);
if (now < pre_endTime) {
ico_stage = STAGE_PRE_ICO;
} else {
ico_stage = STAGE_MAIN_ICO;
}
if ( fundRaised >= _presaleSupply ) {
ico_stage = STAGE_MAIN_ICO;
}
uint256 weiAmount = msg.value;
uint tokens = weiAmount.mul(getPrice(... | 1 |
function storeAuthenticity(string sha256) {
if (checkAuthenticity(sha256) == 0) {
authenticity[sha256] = now;
}
} | 1 |
function canWithdraw(address _thePool)
external
view
returns (bool)
{
if (now >= performers[_thePool].endTime) {
return true;
}
} | 0 |
modifier notYetAccepted(uint _bountyId, uint _fulfillmentId){
require(fulfillments[_bountyId][_fulfillmentId].accepted == false);
_;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'Z1Coin';
string public symbol = 'Z1C';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (address => uint2... | 0 |
function PDOne() public
{
owner = msg.sender;
balances[owner] = 70000000 * (uint256(10) ** decimals);
balances[address(this)] = 180000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function increaseAllowance(address spender, uint256 addedValue)
external
notPaused
notFrozen(msg.sender)
notFrozen(spender)
returns (bool)
{
_approve(msg.sender, spender, data.allowed(msg.sender, spender).add(addedValue));
return true;
} | 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 receiverWithdraw()
public
{
require(msg.sender == receiver);
require(totalAmountRaised >= minimumAmountRequired);
require(this.balance > 0);
require(block.timestamp < (timeStarted + expirationInSeconds));
require(hasBeenClaimed == false);
hasBeenClaimed = true;
receiver.transfer(this.balance);
} | 0 |
function currentTime() constant returns (uint _currentTime) {
return now;
} | 1 |
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 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 canWithdraw() public view returns (bool) {
return totalWeiReceived >= minCapWei || now > refundDeadlineTime;
} | 0 |
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
} | 0 |
function BTCPToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
constructor(address _lrcTokenAddress) public {
require(_lrcTokenAddress != address(0));
lrcTokenAddress = _lrcTokenAddress;
} | 0 |
function initiatable(bytes32 _swapID) external view returns (bool) {
return (swapStates[_swapID] == States.INVALID);
} | 0 |
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
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... | 0 |
function buyEnabled()
external
view
returns (bool);
function matchingEnabled()
external
view
returns (bool);
function _rank(
uint256 id
)
external
view
returns (SortInfo memory);
function _best(
address sell_gem,
address buy_gem
)
external
view
returns (uint256);
function _span(
address sell_gem,
... | 0 |
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
} | 0 |
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
emit Mint(to, value);
return true;
} | 0 |
function supplyBurn(uint256 _value) external onlyRole(ROLE_BURN) returns (bool) {
require(_value > 0);
balances[supplier] = balances[supplier].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(supplier, _value);
return true;
} | 0 |
function isICOActive() public constant returns (bool active) {
active = ((saleStartTimestamp <= now) && (now < saleStopTimestamp) && (!goalReached));
return active;
} | 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)... | 0 |
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
revert();
}
_;
} | 0 |
function addMember(address targetMember, string memberName) onlyOwner public {
uint id = memberId[targetMember];
if (id == 0) {
memberId[targetMember] = members.length;
id = members.length++;
}
members[id] = Member({member: targetMember, memberSince: now, name: memberName});
MembershipChanged(targetMember, true)... | 1 |
function buyOmegaEgg() payable external {
require(msg.value >= 0.09 ether);
require(START_DATE <= now && now < END_DATE);
require(eggOwners[msg.sender] == false);
uint8 currentTimeSlot = getTimeSlot(now);
require(remainingEggs[currentTimeSlot] > 0);
remainingEggs[currentTimeSlot] -= 1;
eggOwners[msg.sender] = tr... | 0 |
function isActive()
public
constant
returns(bool)
{
return (
started &&
totalCollected < hardCap &&
block.timestamp >= startTimestamp &&
block.timestamp < endTimestamp
);
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AirSwapExchange {
mapping (bytes32 => bool) public fills;... | 1 |
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
} | 0 |
function release(uint256 timestamp) public onlyOperator returns(bool) {
require(timestamp <= block.timestamp);
if(lastReleaseTime > 0){
require(timestamp > lastReleaseTime);
}
require(!hasItBeenReleased(timestamp));
cycleCount = releasedCount.div(30);
require(cycleCount < 100);
require(releasedSupply < valueTot... | 0 |
function getTime() internal returns (uint256) {
return now;
} | 1 |
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)) ... | 0 |
function refund() public;
function updateTokenBalance() public;
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
addre... | 0 |
function record(string hash) returns (bool success, bool already, uint theBlock) {
if (msg.value < price) {
success = false;
msg.sender.send(msg.value);
return;
}
if (_records[hash].exists) {
success = true;
already = true;
theBlock = _records[hash].createdIn;
} else {
_records[hash].exists = true;
_records... | 1 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 3