function string | label int64 |
|---|---|
function signedTransferFromHash(Data storage , address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
hash = keccak256(signedTransferFromSig, address(this), spender, from, to, tokens, fee, nonce);
} | 0 |
function getEggsToHatchDragon() public view returns (uint) {
uint256 timeSpent = SafeMath.sub(now,contractStarted);
timeSpent = SafeMath.div(timeSpent, 3600);
return SafeMath.mul(timeSpent, 10);
} | 0 |
function submit(bytes32 Bets, bytes32 secretKey_P, bytes32 secretKey_D_hash) payable public {
require(TicketPool[secretKey_D_hash].Time == 0);
require(msg.value >= LimitBottom && msg.value <= LimitTop);
uint bet_total_amount = 0;
for (uint i = 0; i < 29; i++) {
if(Bets[i] == 0x00) continue;
uint bet_amount_ = uin... | 0 |
function authCall(address from, bytes32 hash) external returns (uint8 code) {
if (!masterKeys[from] && !trustedClients[msg.sender]) {
Unauthorized(from);
return 0;
}
if (functionCalling[from] == 0) {
if (functionCalls[hash] == 0x0) {
functionCalls[hash] = from;
functionCalling[from] = hash;
AuthInit(from);
re... | 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 cancelAgreement(uint256 agreementId) external validAgreement(agreementId) agreementPartiesOnly(agreementId) {
if (withdrawableAmount(agreementId) > 0) {
withdrawTokens(agreementId);
}
uint256 releasedAmount = agreements[agreementId].releasedAmount;
uint256 canceledAmount = agreements[agreementId].totalAmo... | 0 |
constructor() public
{
owner = msg.sender;
balances[owner] = 40000000 * 10 **18;
_totalsupply = balances[owner];
lockstatus = true;
stage = Stages.NOTSTARTED;
emit Transfer(0, owner, balances[owner]);
} | 0 |
function recalcBonuses() internal;
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function calculatePermillToRelease(uint256 _startTime) internal view returns (uint256 permill) {
uint periodsPassed = ((now.sub(_startTime)).div(Interval)).add(1);
permill = periodsPassed.mul(125);
} | 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 calculatePrice(uint weiAmount, address customer) internal constant returns (uint) {
uint investedAmount = investedAmountOf[customer].add(weiAmount);
uint decimalTokensPerWei;
if (investedAmount <= 20 * (10**18) && !discountedInvestors[customer]) {
decimalTokensPerWei = decimalTokensPerWei2Eth;
} else if (... | 0 |
function investETH(address referral) public payable {
require(now >= launchtime);
require(msg.value >= 0.1 ether);
uint256 timelimit = SafeMath.sub(now, launchtime);
if(timelimit < 1728000 && getProfit(msg.sender) > 0){
reinvestProfit();
}
if(timelimit > 1728000 && getProfit(msg.sender) > 0){
uint256 profit = g... | 0 |
function canAddToVault() external view canPoSMint returns(bool) {
return true;
} | 0 |
function StealResources(uint _planetId) {
require(addressPlanetsCount[msg.sender] > 0);
require(planets[_planetId].ownerAddress != msg.sender);
require(planets[_planetId].curResources > 0);
if(addressAttackCount[msg.sender] > addressDefenseCount[planets[_planetId].ownerAddress]) {
uint random = uint(keccak256(now,... | 1 |
modifier not_upgraded() {
require(ptr == address(0), "upgrade pointer is non-zero");
_;
} | 0 |
function approveAllAndCall(address _spender, bytes _extraData) public returns (bool success) {
return approveAndCall(_spender, balanceOf[msg.sender], _extraData);
} | 0 |
function _setPayTo(address newPayTo) internal {
_payTo = newPayTo;
} | 0 |
function updateUsdEthRate(uint256 _rate) public onlyOwner {
require(_rate > 0);
require(rate != _rate);
emit UpdateUsdEthRate(_rate);
rate = _rate;
timestamp = now;
} | 0 |
function searchWhitelist(address _address) view public returns (string){
return (Whitelists[_address].Email);
} | 0 |
function isSuccessful()
public
constant
returns(bool)
{
return (
totalCollected >= hardCap ||
(block.timestamp >= endTimestamp && totalCollected >= minimalGoal)
);
} | 0 |
function disableMinting(Data storage self) public {
require(self.mintable);
require(msg.sender == self.minter || msg.sender == self.owner);
self.mintable = false;
if (self.minter != address(0)) {
MinterUpdated(self.minter, address(0));
self.minter = address(0);
}
MintingDisabled();
} | 0 |
function addBalance(address participant, uint256 value) private {
balanceOf[participant] = safeIncrement(balanceOf[participant], value);
totalFunding = safeIncrement(totalFunding, value);
LogParticipation(participant, value, now);
} | 0 |
function withdrawToWallet() public onlyOwner {
wallet.transfer(this.balance);
emit Withdrawn(wallet);
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 _allowance);
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
function approve(address _spender, uint256 ... | 0 |
function getBonus(uint256 _tokens, uint256 _weiAmount) public view returns (uint256) {
if (_weiAmount >= 30 ether) {
return _tokens.mul(secondBonus).div(100);
}
return _tokens.mul(firstBonus).div(100);
} | 0 |
function isTransformAgent() public constant returns (bool) {
return true;
} | 0 |
function totalSupply() external constant returns (uint256) {
return generalTokens + reservedTokens;
} | 0 |
function payoutAmount() public view returns(uint) {
uint persent = persentRate();
uint rate = userDeposit[msg.sender].mul(persent).div(100000);
uint interestRate = now.sub(userTime[msg.sender]).div(chargingTime);
uint withdrawalAmount = rate.mul(interestRate);
return (withdrawalAmount);
} | 0 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, 0x0, _value);
} | 0 |
function notarize(string sha256) {
if ( bytes(sha256).length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 |
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using ECRecovery for bytes32;
uint8 constant public STATUS_NO_DEAL = 0x0;
uint8 constant public STATUS_DEAL_WAIT_CONFIRMATION = 0x01;
uint8 constant pu... | 0 |
function endSale() onlyOwner public
{
require(saleTime == true);
require(maxSaleSupply == tokenIssuedSale);
saleTime = false;
uint nowTime = now;
endSaleTime = nowTime;
for(uint i = 0; i < advSptVestingTime; i++)
{
uint lockTime = endSaleTime + (advSptVestingDate * i);
advSptVestingTimer[i] = lockTime;
advSp... | 0 |
function vestedAmount(ERC20Basic token) public constant returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= startTime.add(duration) || revoked[token]) {
return totalBalance;
} else {
return... | 0 |
function setBeneficiary(address newBeneficiary) ownerOnly {
beneficiary = newBeneficiary;
} | 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);
} | 0 |
function mint(address account, uint256 value) public onlyOwner{
require(value > 0);
require(now > nextminttime);
uint256 canminttokenamount = totalSupply().mul(2).div(100);
require(canminttokenamount >= value);
uint year = now.sub(nextminttime).div(365 days);
nextminttime += (year + 1) * 365 days;
_mint(account,... | 0 |
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address... | 0 |
function unpause() external requireGod whenPaused {
paused = false;
} | 0 |
function reviewAudit(uint _id) external onlyOwner {
require(audits[_id].status == AuditStatus.InProgress);
require(block.timestamp >= audits[_id].endTime);
audits[_id].endTime = block.timestamp;
audits[_id].status = AuditStatus.InReview;
emit ReviewingAudit(_id);
} | 0 |
function AxiePresale() public {
priceIncrements[CLASS_BEAST] = priceIncrements[CLASS_AQUATIC] =
priceIncrements[CLASS_PLANT] = INITIAL_PRICE_INCREMENT;
currentPrices[CLASS_BEAST] = currentPrices[CLASS_AQUATIC] =
currentPrices[CLASS_PLANT] = INITIAL_PRICE;
} | 1 |
function close() public onlyOwner beforeEnd {
_burn(saleTokensAddress, balances[saleTokensAddress]);
_burn(bountyTokensAddress, balances[bountyTokensAddress]);
saleClosed = true;
} | 0 |
function numberOfDeployedTokens() public view returns (uint) {
return deployedTokens.length;
} | 0 |
function cancelOrder(Order memory order)
public
nonReentrant
{
cancelOrderInternal(order);
} | 0 |
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
pragma solidity ^0.4.18;
contract Mintable {
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {... | 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 distributePresaleTokens(address _buyer, uint tokens) external onlyOwner whenNotPaused {
require(_buyer != address(0));
require(tokens > 0 && tokens <= 10e24);
require(tokensDistributedPresale < 10e24);
tokensDistributedPresale = tokensDistributedPresale.add(tokens);
balances[_buyer] = balances[_buyer].add... | 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 setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
if(releaseAgent != 0) {
throw;
}
releaseAgent = addr;
} | 0 |
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 value);
}
contract Burnable {
function burnTokens(address account, uint value) in... | 0 |
function approve(Data storage self, address spender, uint tokens) public returns (bool success) {
require(!self.accountLocked[msg.sender]);
self.allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
} | 0 |
modifier handleDerivativeTokens(address from) {
if (nextDerivativeTokenScheduled && now > nextDerivativeTokenTime) {
derivativeTokens.push(nextDerivativeToken);
nextDerivativeTokenScheduled = false;
delete nextDerivativeTokenTime;
delete nextDerivativeToken;
}
for (uint256 i = lastDerivativeTokens[from]; i < der... | 1 |
function approveCrowdsale(address _crowdsaleAddress) external;
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 re... | 0 |
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveAndCallCheck(address(this), tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
} | 0 |
function setupExportFee(address addr, uint256 fee) onlyOwnerUnlocked {
exportFee[addr] = fee;
activateExportFeeChargeRecord(addr);
FeeSetup(msg.sender, addr, fee);
} | 0 |
constructor(ReadableI _makerDAOMedianizer) public {
require(_makerDAOMedianizer != address(0));
makerDAOMedianizer = _makerDAOMedianizer;
weiPerUnitRate = convertToRate(_makerDAOMedianizer.read());
lastTimeUpdated = now;
} | 0 |
function changeMinContribution(uint256 _minContribution) public onlyOwner {
require(_minContribution > 0);
minContribution = _minContribution;
} | 0 |
function takeOwnership(uint256 _tokenId) public {
require(isApprovedFor(msg.sender, _tokenId));
clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
}
contract Bassdrops is EtherealFoundationOwned {
string public constant CONTRACT_NAME = "Bassdrops";
string public constant CONTRACT_VERSION = "A";
string public constant QUOTE = "It’s a permanent, perfect SIMULTANEOUS dichotomy of total insignific... | 1 |
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract PVCCrowdsale is Ownable{
using SafeMath for uint256;
TokenI... | 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 approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
bal... | 0 |
function assignTokens(address receiver, uint tokenAmount) private {
token.mint(receiver, tokenAmount);
} | 0 |
function purchaseCity(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
City storage city = cityData[_tokenId];
uint256 price = city.price;
address oldOwner = city.owner;
address newOwner = msg.sender;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 excess... | 1 |
function owner()
external
returns(address);
function updateContractAddress(
string _name,
address _address
)
external
returns (address);
function getContractAddress(
string _name
)
external
view
returns (address);
}
interface IBrickblockToken {
function transfer(
address _to,
uint256 _value
)
externa... | 0 |
modifier isNotTimeLocked() {
require(now >= timelockedAccounts[msg.sender]);
_;
} | 0 |
function setTreasuryAddress (address treasury) external onlyOwner {
_treasury = treasury;
} | 0 |
function secondaryICO(bool _icoOverride) onlyOwner public {
icoOverride = _icoOverride;
} | 0 |
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(_owner);
_owner = address(0);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract CVEN is ERC20 {
using SafeMath for uint256;
string public constant name = "Concordia Ventures Stablecoin";
string public constant symbol = "CVEN";
uint8 public constant decimals = 18;
uint256 public _totalsupply;
uint256 public mintedTokens;
... | 0 |
function stakeMaximum () external view returns (uint256) {
return _stakeMaximum;
} | 0 |
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
fu... | 0 |
function approve(address _spender, uint256 _value) public returns (bool){
require(_value >= 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function finishDeal(uint256 _dealId) public onlyOwner {
require(deals[_dealId].state == DealState.InProgress);
if (deals[_dealId].customerAns && deals[_dealId].beneficiaryAns) {
deals[_dealId].beneficiary.transfer(deals[_dealId].value);
deals[_dealId].agent.transfer(deals[_dealId].commission);
deals[_dealId].state... | 1 |
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEth... | 0 |
function hasStarted() public view returns (bool) {
return now >= startTime;
} | 0 |
modifier requireAuthorizedLogicContract() {
require(msg.sender == authorizedLogicContractAddress);
_;
} | 0 |
constructor() public {
totalSupply = 1000000000e8;
balances[investorsAllocation] = investorsTotal;
balances[teamAllocation] = teamTotal;
balances[advisorsAllocation] = advisorsTotal;
balances[bountyAllocation] = bountyTotal;
balances[liquidityPoolAllocation] = liquidityPoolTotal;
balances[contributorsAllocation]... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
} | 0 |
function hodl(uint256 _id, uint256 _value, uint256 _months) external {
require(_id > 0);
require(_value > 0);
require(_months == 3 || _months == 6 || _months == 12);
address _user = msg.sender;
Item storage item = items[_user][_id];
require(item.id != _id);
uint256 _seconds = _months.mul(2628000);
uint256 _rele... | 0 |
function transfer(address _to, uint _value)
public
canTransfer(msg.sender, _value)
returns (bool success)
{
return super.transfer(_to, _value);
} | 0 |
function multisigAddress() public constant returns(address){
return multisig;
} | 0 |
function time() public constant returns (uint)
{
return block.timestamp;
} | 1 |
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) e... | 0 |
function OBGAllocation(address _prospectors_team) internal {
obg = ProspectorsObligationToken(msg.sender);
unlockedAt = now + 1 days;
allocations[_prospectors_team] = 30000;
} | 0 |
modifier validateTrasfer() {
_;
assert(balances[founders] >= 100000000 ether || teamTransferFreeze < now);
} | 1 |
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedApproveAndCall(address(this), tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
} | 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 ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256... | 0 |
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function s... | 0 |
function destroyTokens(uint256 destroyAmount) multisig(sha3(msg.data)) {
assert(treasuryBalance >= destroyAmount);
treasuryBalance -= destroyAmount;
totalSupply -= destroyAmount;
} | 0 |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
} | 0 |
function accountLocked(address tokenOwner) public view returns (bool) {
return data.accountLocked[tokenOwner];
} | 0 |
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success) {
return data.mint(tokenOwner, tokens, lockAccount);
} | 0 |
function validBalanceOf(address addr) constant public returns (uint) {
FreezingNode[] memory nodes = c_freezing_list[addr];
uint length = nodes.length;
uint total_coins = balanceOf(addr);
for (uint i = 0; i < length; ++i) {
if (nodes[i].end_stamp > block.timestamp) {
total_coins = sub(total_coins, nodes[i].num_co... | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
} | 0 |
function is_leap_year() private{
if(now >= _year + 31557600){
_year = _year + 31557600;
_year_count = _year_count + 1;
_currentMined = 0;
_miningReward = _miningReward/2;
if(((_year_count-2018)%5 == 0) && (_year_count != 2018)){
_maxMiningReward = _maxMiningReward/2;
}
if((_year_count%4 == 1) && ((_year_count-... | 0 |
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function unhalt() onlyManager onContractStopped public {
halted = false;
} | 0 |
function receiveApproval(address from, uint256 amount, address currency, bytes extraData) external {
Token(currency).transferFrom(from, this, amount);
HotWalletDeposit(from, amount);
} | 0 |
function adjustFeeEntitlement(address account, uint preBalance)
internal
{
rolloverFee(account, lastTransferTimestamp[account], preBalance);
currentBalanceSum[account] = safeAdd(
currentBalanceSum[account],
safeMul(preBalance, now - lastTransferTimestamp[account])
);
lastTransferTimestamp[account] = now;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.