function string | label int64 |
|---|---|
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 getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed=min(EGGS_TO_HATCH_1SHRIMP,SafeMath.sub(now,lastHatch[adr]));
return SafeMath.mul(secondsPassed,hatcheryShrimp[adr]);
} | 0 |
function RBAC()
public
{
addRole(msg.sender, ROLE_ADMIN);
} | 0 |
function totalSupply() constant returns (uint256);
function allowance(address _owner, address _spender) constant returns (uint256);
function approve(address _owner, address _spender, uint256 _amountBabz) public;
function transfer(address _from, address _to, uint256 _amountBabz, bytes _data) public;
function transfe... | 0 |
function updatePartner1_will(string _partner1_will) public {
require(msg.sender == partner1_address);
partner1_will = _partner1_will;
saveContractEvent("Update - Will", "Partner 1 Will Updated");
} | 0 |
function DataKnowYourCustomer(address _etherProceedsAccount) {
etherProceedsAccount = _etherProceedsAccount;
balances[etherProceedsAccount] += CAP;
Transfer(this, etherProceedsAccount, CAP);
} | 0 |
function solveBet(address player, uint8 result, bool win, uint8 multiplier) private
{
playerStatus[player]=Status.waitingForBet;
gambles[gambleIndex[player]].spinned=true;
uint bet_v = gambles[gambleIndex[player]].wager;
if (win)
{
if (player!=gambles[gambleIndex[player]].player) throw;
gambles[gambleIndex[play... | 0 |
function paused() public;
function unpause() public;
function finishMinting() public returns (bool);
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
} | 0 |
function MonLockupFund () public {
token = ERC20Interface(tokenAddress);
} | 0 |
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;
require(
c / a == b,
"UINT256_OVERFLOW"
);
return c;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (now < baseStartTime) revert();
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return fals... | 1 |
function getCurrentContextAddress()
internal
view
returns (address)
{
address currentContextAddress_ = currentContextAddress;
address contextAddress = currentContextAddress_ == address(0) ? msg.sender : currentContextAddress_;
return contextAddress;
} | 0 |
modifier isPriceFeed() {
require(msg.sender == priceFeed1 || msg.sender == priceFeed2 || msg.sender == priceFeed3);
_;
} | 0 |
function validPurchase(uint256 tokensAmount) internal view returns (bool) {
bool nonZeroPurchase = tokensAmount != 0;
bool acceptableAmount = tokensAmount >= getMinimumPurchase();
return nonZeroPurchase && acceptableAmount;
} | 0 |
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
return true;
} | 0 |
function ceiling() constant returns (uint256);
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant retu... | 0 |
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
... | 0 |
modifier afterFrozenDeadline() {
if (now >= freeCrawDeadline)
_;
} | 0 |
function getNext() public returns (uint);
function subRemainsForTap(uint _delta) public;
}
contract Tap is ITap, Ownable {
function init(uint _baseEther, uint _startDate) public onlyOwner {
require(baseEther == 0);
baseEther = _baseEther;
remainsForTap = _baseEther;
nextTapDate = _startDate;
} | 0 |
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 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, u... | 0 |
function burn(uint256 value) public {
_burn(msg.sender, value);
} | 0 |
function canWithdraw() public view returns (bool) {
return true;
} | 0 |
function withdrawERC20(address ERC20Token, address recipient) external onlyOwner {
uint256 amount = IERC20(ERC20Token).balanceOf(address(this));
IERC20(ERC20Token).transfer(recipient, amount);
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
contract FIICToken is Ownable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals = 0;
uint256 public totalSupply;
mapping (address =>... | 0 |
function auditSecret(bytes32 _swapID) external view onlyClosedSwaps(_swapID) returns (bytes32 secretKey) {
Swap memory swap = swaps[_swapID];
return swap.secretKey;
} | 0 |
function transferToContract(address _to, uint256 _value, bytes _data) internal {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub( _value);
balances[_to] = balances[_to].add( _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
e... | 0 |
function name() pure public returns (string) {
return 'Knowledge.io';
} | 0 |
function transferTokens(ERC20 token, address from, address to, uint256 amount, uint256 fee, uint256 nonce, uint256 expires, uint8 v, bytes32 r, bytes32 s) external onlyRole(ROLE_TRANSFER_TOKENS) {
bytes32 hash = keccak256(this, token, from, to, amount, fee, nonce, expires);
require(expires >= now);
require(transferr... | 0 |
function holosForWei(uint256 amountWei) internal view returns (uint256) {
return amountWei * rate / 1000000000000000000;
} | 0 |
function walletData(address _wallet) public view returns (string) {
return whitelist[_wallet].data;
} | 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 |
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() consta... | 0 |
function init(uint _startDate, uint _duration, uint8 _subject) private {
require(!inProgress());
require(_startDate >= now);
require(_subject > 0 && _subject <= 100);
currentVoting += 1;
startDate = _startDate;
endDate = _startDate + _duration;
votesYes = 0;
votesNo = 0;
subject = _subject;
emit InitVoting(_s... | 0 |
function purchaseEstate(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
Estate storage estate = estateData[_tokenId];
uint256 price = estate.price;
address oldOwner = estate.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price... | 1 |
function withdrawInvestment(uint256 amountToWithdrawInWei)
noEthSent
{
updateBalances();
if (amountToWithdrawInWei>balance[msg.sender]) throw;
uint8 investorID=255;
for (uint8 k = 0; k<setting_maxInvestors; k++)
{
if (investors[k].investor==msg.sender)
{
investorID=k;
break;
}
}
if (investorID==255) throw... | 0 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 is Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint256 public decimals = 18;
uint256 DEC = 10 ** uint256(decimals);
uint256 public totalSupply;
uint256 public... | 0 |
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint _amount)public returns (bool ok);
function approve(address _spender, uint _amount)public returns (bool ok);
function transfer(address _to, uint _amount)public returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint _amount);
event App... | 0 |
modifier onlyManager() {
require(msg.sender == addressManager);
_;
} | 0 |
function Wolk()
{
start_block = 3831300;
end_block = 3831900;
balances[msg.sender] = wolkFund;
reservedTokens = 25 * 10**decimals;
allocations[0x564a3f7d98Eb5B1791132F8875fef582d528d5Cf] = 20;
allocations[0x7f512CCFEF05F651A70Fa322Ce27F4ad79b74ffe] = 1;
allocations[0x9D203A36cd61b21B7C8c7Da1d8eeB13f04bb24D9] = ... | 0 |
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
} | 1 |
constructor () public {
initialized = false;
norsefirePrice = 0.1 ether;
currentNorsefire = 0x4d63d933BFd882cB0A9D73f7bA4318DDF3e244B0;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender)
public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value)
public returns (bool);
function transferFrom(address... | 0 |
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
} | 0 |
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
function checkBalance(address acc, string currencyAndBank) constant returns (uint128 balance) {
bytes32 cab = sha3(currencyAndBank);
return balances[acc][cab];
} | 0 |
function setFeeCollector(address _collector) public{
require(msg.sender == owner, "Delegatable: only owner change the fee collector");
_setFeeCollector(_collector);
} | 0 |
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
} | 1 |
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
assert(b <= a);
return a - b;
} | 0 |
function _pRand(uint _modulo) internal view returns (uint) {
require((1 < _modulo) && (_modulo <= 1000));
uint seed1 = uint(block.coinbase);
uint seed2 = now;
seed3++;
return uint(keccak256(seed1, seed2, seed3)) % _modulo;
} | 1 |
function listAddress( address _user, uint _cap ) onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 0 |
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys)... | 0 |
function updateLosingBidder() internal {
losingBidder = winningBidder;
losingBid = winningBid;
} | 0 |
function updateOrderbook(Orderbook _newOrderbookContract) external onlyOwner {
emit LogOrderbookUpdated(orderbookContract, _newOrderbookContract);
orderbookContract = _newOrderbookContract;
} | 0 |
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
} | 0 |
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) constant public returns (uint256 remaining);
event Transfer(address indexed _from, ad... | 0 |
function setTotalSupply(uint256 _newValue) internal
{
totSupply=_newValue;
} | 0 |
function transferFrom(Data storage self, address from, address to, uint tokens) public returns (bool success) {
require(self.transferable);
require(!self.accountLocked[from]);
self.balances[from] = safeSub(self.balances[from], tokens);
self.allowed[from][msg.sender] = safeSub(self.allowed[from][msg.sender], tokens)... | 0 |
function transferFrom(address from, address to, uint256 value) canTrade {
require(to != 0x0);
require(!isLocked(from));
uint256 _allowance = allowed[from][msg.sender];
require(value > 0 && _allowance >= value);
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.... | 0 |
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);
function totalSupply() external view returns (uint256);
function balanceOf(address w... | 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 ... | 0 |
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 (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function investETH(address referral) public payable {
require(msg.value >= 0.1 ether);
if(getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
uint256 commision = SafeMath.div(amount, 20);
if(referral != msg... | 0 |
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);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint valu... | 0 |
function bpLockUp(address _to) onlyOwner public
{
require(tokenLock == false);
require(saleTime == false);
uint time = now;
uint unlockTokens = 0;
if( (time >= bpLock_1) && (bp1[_to] > 0) )
{
balances[_to] = balances[_to].add(bp1[_to]);
unlockTokens = unlockTokens.add(bp1[_to]);
bp1[_to] = 0;
}
if( (time >=... | 0 |
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool withinContributionLimit = msg.value >= minimumContribution && msg.value <= maximumContribution;
return withinPeriod && nonZeroPurchase && withinContribution... | 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
);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mappin... | 0 |
function _isContract(address _addr) private view returns (bool is_contract){
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
} | 0 |
function today() private constant returns (uint) {
return now / 1 days;
} | 1 |
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseAllowance(spender, subtractedValue);
} | 0 |
function betOnLowHigh(bool Low, bool High)
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
uint8 count;
uint8 input;
if (Low)
{
count+=1;
input=0;
}
if (High)
{
count+=1;
input=1;
}
if (count!=1) throw;
uint256 betValue= checkBetValue();
gambles.push(Gamble(msg.sender, ... | 0 |
function is_leap_year() private{
if(now >= _year + 31557600){
_year = _year + 31557600;
_year_count = _year_count + 1;
_currentMined = 0;
if(((_year_count-2018)%4 == 0) && (_year_count != 2018)){
_maxMiningReward = _maxMiningReward/2;
_miningReward = _maxMiningReward/10000;
}
if((_year_count%4 == 1) && ((_year... | 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 sale(uint256 _id, uint256 _price) public returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(lottery.getHolder(_id) == msg.sender);
priceList[_id] = _price;
holderList[_id] = msg.sender;
a... | 0 |
function setLottery(address _lottery) public onlyOwner {
require(!started);
lottery = InterfaceDeusETH(_lottery);
deusETH = _lottery;
started = 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 ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (ui... | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
} | 0 |
function setOwner(address newOwner) onlyOwner {
SetOwner(owner, newOwner);
owner = newOwner;
} | 0 |
function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
minCap = _globalMinCap;
balances[owner] = total... | 0 |
function allowance(address _owner, address _spender) constant public returns (uint256) {
return c_approvals[_owner][_spender];
} | 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 |
modifier whenUpgradeEnabled() {
require(upgradeAgent != address(0));
_;
} | 0 |
function toRelease(address who) public view returns(uint256) {
uint256 teamTokens = _teamToRelease(who);
uint256 advisorsTokens = _advisorsToRelease(who);
return teamTokens.add(advisorsTokens);
} | 0 |
function safeSub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
} | 0 |
constructor(uint256 initialSupply,string memory tokenName,string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
} | 0 |
function _generateWeapon(address _owner, uint256 _weaponId) internal returns (uint256 id) {
require(weaponModels[_weaponId].price > 0);
require(msg.value == weaponModels[_weaponId].price);
id = weaponEntities.length;
uint256 createTime = block.timestamp;
uint256 seed = uint(block.blockhash(block.number - 1)) + uin... | 1 |
function Balances() public {
_balances[msg.sender] = 190 * 1000000 * 1000000000000000000;
} | 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
FeeAddr.transfer(_com);
uint256 _p3d;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_aff... | 0 |
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
} | 0 |
function getNext() public onlyOwner returns (uint) {
require(nextTapNum < 12);
require(remainsForTap > 0);
require(now >= nextTapDate);
uint tapValue;
if (nextTapNum == 11) {
tapValue = remainsForTap;
} else {
tapValue = uint(nextTapPercent) * baseEther / 100;
if (tapValue > remainsForTap) {
tapValue = remain... | 0 |
function safeMul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
} | 0 |
function setImportFee(address addr, uint256 fee) multisig(sha3(msg.data)) {
uint256 max = 1;
max = pow10(1, decimals);
assert(fee <= max);
importFee[addr] = fee;
activateImportFeeChargeRecord(addr);
} | 0 |
function transferFrom(address from, address to, uint256 value) returns (bool);
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 => uint25... | 0 |
function buyFuel(address beneficiary) public payable whenNotPaused{
require(currentDay() > 0);
require(whitelistContract.isWhitelisted(beneficiary));
require(beneficiary != 0x0);
require(withinPeriod());
uint256 amountOfHolosAsked = holosForWei(msg.value);
uint dayIndex = statsByDay.length-1;
Day storage today =... | 0 |
function vestedTokens(address _holder, uint256 _time) external view returns (uint256) {
Grant memory grant_ = grants[_holder];
if (grant_.value == 0) {
return 0;
}
return calculateVestedTokens(grant_, _time);
} | 0 |
function _rand() private view returns(uint256) {
uint256 rand = uint256(sha3(now, block.number, randSeed));
return rand %= (10 ** 6);
} | 0 |
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address ... | 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 ... | 0 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_... | 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 SafeMath {
func... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.