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 transferFrom(address _sender, address _from, address _to, uint256 _amountBabz, bytes _data) public;
function floor() constant returns (uint256);
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 returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
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() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 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[player]].win=true;
uint win_v = multiplier*bet_v;
lossSinceChange+=win_v-bet_v;
Win(player, result, win_v);
if (player.send(win_v)==false) throw;
}
else
{
Loss(player, result, bet_v);
profitSinceChange+=bet_v;
}
} | 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 false;
}
} | 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 returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
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() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 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;
function Ownable() {
owner = msg.sender;
} | 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, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address _owner) public constant returns (uint256){
return balances[_owner];
} | 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 => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
struct LockFund {
uint256 amount;
uint256 startTime;
uint256 lockUnit;
uint256 times;
bool recyclable;
}
mapping (address => LockFund) public lockFunds;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
event LockTransfer(address indexed acc, uint256 amount, uint256 startTime, uint256 lockUnit, uint256 times);
event recycleToke(address indexed acc, uint256 amount, uint256 startTime);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0),"目的地址不能为空");
require(_from != _to,"自己不能给自己转账");
require(balanceOf[_from] - getLockedAmount(_from) >= _value,"转账的数量不能超过可用的数量");
require(balanceOf[_to] + _value > balanceOf[_to],"转账的数量有问题");
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function getLockedAmount(address _from) public view returns (uint256 lockAmount) {
LockFund memory lockFund = lockFunds[_from];
if(lockFund.amount > 0) {
if(block.timestamp <= lockFund.startTime) {
return lockFund.amount;
}
uint256 ap = lockFund.amount.div(lockFund.times);
uint256 t = (block.timestamp.sub(lockFund.startTime)).div(lockFund.lockUnit);
if(t < lockFund.times) {
return lockFund.amount.sub(ap.mul(t));
}
}
return 0;
}
function getReleaseAmount(address _from) public view returns (uint256 releaseAmount) {
LockFund memory lockFund = lockFunds[_from];
if(lockFund.amount > 0) {
if(block.timestamp <= lockFund.startTime) {
return 0;
}
uint256 ap = lockFund.amount / lockFund.times;
uint256 t = (block.timestamp - lockFund.startTime) / lockFund.lockUnit;
if(t>= lockFund.times){
return lockFund.amount;
}
return ap * t;
}
return balanceOf[_from];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
function lockTransfer(address _lockAddress, uint256 _lockAmount, uint256 _startReleaseTime, uint256 _releaseInterval, uint256 _releaseTimes,bool _recyclable) onlyOwner public {
_transfer(msg.sender, _lockAddress, _lockAmount);
LockFund storage lockFund = lockFunds[_lockAddress];
lockFund.amount = _lockAmount;
lockFund.startTime = _startReleaseTime;
lockFund.lockUnit = _releaseInterval;
lockFund.times = _releaseTimes;
lockFund.recyclable = _recyclable;
emit LockTransfer(_lockAddress, _lockAmount, _startReleaseTime, _releaseInterval, _releaseTimes);
}
function recycleRemainingToken(address _lockAddress) onlyOwner public{
LockFund storage lockFund = lockFunds[_lockAddress];
require(lockFund.recyclable == true,"该地址不支持撤销操作");
uint256 remaingCount = getLockedAmount(_lockAddress);
require(balanceOf[owner()] + remaingCount > balanceOf[owner()],"转账的数量有问题");
uint previousBalances = balanceOf[owner()] + balanceOf[_lockAddress];
balanceOf[_lockAddress] -= remaingCount;
balanceOf[owner()] += remaingCount;
lockFund.amount = 0;
emit recycleToke(_lockAddress,remaingCount,block.timestamp);
emit Transfer(_lockAddress, owner(), remaingCount);
assert(balanceOf[owner()] + balanceOf[_lockAddress] == previousBalances);
}
} | 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);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
} | 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(transferred[hash] == false);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) == from);
balanceOf[address(token)][from] = balanceOf[address(token)][from].sub(amount.add(fee));
balanceOf[address(token)][feeAccount] = balanceOf[address(token)][feeAccount].add(fee);
balanceOf[address(token)][to] = balanceOf[address(token)][to].add(amount);
TransferredTokens(token, from, to, amount, fee, nonce);
} | 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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, 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() constant returns (uint256);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 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(_startDate, endDate, subject);
} | 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);
require(oldOwner != msg.sender);
uint256 profit = price.sub(estate.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(3).div(100);
devOwed = devOwed.add(devCut);
transferEstate(oldOwner, newOwner, _tokenId);
estate.lastPrice = price;
estate.price = getNextPrice(price);
EstatePurchased(_tokenId, newOwner, price);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
} | 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;
if (investors[investorID].time+setting_lockPeriod>now) throw;
if (balance[msg.sender]-amountToWithdrawInWei>=setting_minInvestment && amountToWithdrawInWei!=0)
{
balance[msg.sender]-=amountToWithdrawInWei;
payroll-=amountToWithdrawInWei;
if (msg.sender.send(amountToWithdrawInWei)==false) throw;
withdraw(msg.sender, amountToWithdrawInWei);
}
else
{
uint256 fullAmount=balance[msg.sender];
payroll-=fullAmount;
balance[msg.sender]=0;
delete investors[investorID];
if (msg.sender.send(fullAmount)==false) throw;
withdraw(msg.sender, fullAmount);
}
updateMaxBet();
} | 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 avaliableSupply;
uint256 public buyPrice = 1000000000000000000 wei;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public
{
totalSupply = initialSupply.mul(DEC);
balanceOf[this] = totalSupply;
avaliableSupply = balanceOf[this];
name = tokenName;
symbol = tokenSymbol;
} | 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 Approval(address indexed _owner, address indexed _spender, uint _amount);
}
contract AdBank is ERC20
{ using SafeMath for uint256;
string public constant symbol = "ADB";
string public constant name = "AdBank";
uint8 public constant decimals = 18;
uint256 _totalSupply = (1000000000) * (10 **18);
address public owner;
bool stopped = true;
uint256 public eth_received;
uint256 startdate;
uint256 enddate;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
} | 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] = 2;
allocations[0x5fcf700654B8062B709a41527FAfCda367daE7b1] = 1;
allocations[0xC28dA4d42866758d0Fc49a5A3948A1f43de491e9] = 1;
CreateWolk(msg.sender, wolkFund);
} | 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 from, address to, uint256 value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public _owner;
event OwnershipTransferred(
address indexed previousOwner, address indexed newOwner
);
constructor() public {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
} | 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).eth() );
} | 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, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Coin is ERC20, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal c_totalSupply;
mapping(address => uint256) internal c_balances;
mapping(address => mapping(address => uint256)) internal c_approvals;
function init(uint256 token_supply, string token_name, string token_symbol) internal {
c_balances[msg.sender] = token_supply;
c_totalSupply = token_supply;
name = token_name;
symbol = token_symbol;
} | 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);
self.balances[to] = safeAdd(self.balances[to], tokens);
Transfer(from, to, tokens);
return true;
} | 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.sender] = _allowance.sub(value);
Transfer(from, to, value);
} | 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 who) external view returns (uint256);
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);
}
contract Claimable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
} | 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
);
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
} | 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, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} | 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.sender && referral != 0x1 && referral != promoter && referral != promoter1){
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], commision);
}
affiliateCommision[promoter] = SafeMath.add(affiliateCommision[promoter], commision);
affiliateCommision[promoter1] = SafeMath.add(affiliateCommision[promoter1], commision);
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], amount);
lastInvest[msg.sender] = now;
} | 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 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 StandardToken is ERC20
{
using SafeMath for uint;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
bool public constant isToken = true;
modifier onlyPayloadSize(uint size) {
require(msg.data.length == size + 4);
_;
} | 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 >= bpLock_2) && (bp2[_to] > 0) )
{
balances[_to] = balances[_to].add(bp2[_to]);
unlockTokens = unlockTokens.add(bp2[_to]);
bp2[_to] = 0;
}
emit TokenUnLock(_to, unlockTokens);
} | 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 && withinContributionLimit;
} | 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;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 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, false, false, BetTypes.lowhigh, input, betValue, block.number, 37));
} | 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_count-1)%100 != 0)){
_year = _year + 86400;
}
else if((_year_count-1)%400 == 0){
_year = _year + 86400;
}
}
} | 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) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
} | 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;
assert(lottery.changeHolder(_id, this));
TokenSale(_id, _price);
return true;
} | 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 (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
);
}
contract Vesting {
using SafeMath for uint256;
ERC20 public mycroToken;
event LogFreezedTokensToInvestor(address _investorAddress, uint256 _tokenAmount, uint256 _daysToFreeze);
event LogUpdatedTokensToInvestor(address _investorAddress, uint256 _tokenAmount);
event LogWithdraw(address _investorAddress, uint256 _tokenAmount);
constructor(address _token) public {
mycroToken = ERC20(_token);
} | 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] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
throw;
}
}
} | 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) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 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)) + uint(block.blockhash(block.number - 100))
+ uint(block.coinbase) + createTime + id;
uint256 dna = uint256(keccak256(seed)) % 1000000000000000;
WeaponModel memory weaponModel = weaponModels[_weaponId];
WeaponEntity memory newWeapon = WeaponEntity(_weaponId, weaponModel.weaponType, weaponModel.generation, dna);
weaponEntities.push(newWeapon);
weaponToOwner[id] = _owner;
ownerToWeapons[_owner].push(id);
} | 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_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 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 = remainsForTap;
nextTapNum = 11;
}
}
remainsForTap -= tapValue;
nextTapNum += 1;
if (nextTapNum < 12) {
nextTapPercent = tapPercents[nextTapNum];
nextTapDate += 30 days;
}
return tapValue;
} | 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 => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 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 = statsByDay[dayIndex];
uint256 reservedHolos = whitelistContract.reservedTokens(beneficiary, dayIndex);
uint256 alreadyBought = today.fuelBoughtByAddress[beneficiary];
if(alreadyBought >= reservedHolos) {
reservedHolos = 0;
} else {
reservedHolos = reservedHolos.sub(alreadyBought);
}
uint256 askedMoreThanReserved;
uint256 useFromReserved;
if(amountOfHolosAsked > reservedHolos) {
askedMoreThanReserved = amountOfHolosAsked.sub(reservedHolos);
useFromReserved = reservedHolos;
} else {
askedMoreThanReserved = 0;
useFromReserved = amountOfHolosAsked;
}
if(reservedHolos == 0) {
require(msg.value >= minimumAmountWei);
}
require(lessThanMaxRatio(beneficiary, askedMoreThanReserved, today));
require(lessThanSupply(askedMoreThanReserved, today));
wallet.transfer(msg.value);
tokenContract.mint(beneficiary, amountOfHolosAsked);
today.soldFromUnreserved = today.soldFromUnreserved.add(askedMoreThanReserved);
today.soldFromReserved = today.soldFromReserved.add(useFromReserved);
today.fuelBoughtByAddress[beneficiary] = today.fuelBoughtByAddress[beneficiary].add(amountOfHolosAsked);
CreditsCreated(beneficiary, msg.value, amountOfHolosAsked);
} | 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 indexed owner, address indexed spender, uint value);
}
contract Bitron is ERC20
{ using SafeMath for uint256;
string public constant name = "Bitron coin";
string public constant symbol = "BTO";
uint8 public constant decimals = 18;
uint public _totalsupply = 50000000 * 10 ** 18;
address public owner;
uint256 public _price_tokn;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
address ethFundMain = 0x1e6d1Fc2d934D2E4e2aE5e4882409C3fECD769dF;
uint256 public postico_startdate;
uint256 postico_enddate;
uint256 maxCap_POSTICO;
uint public priceFactor;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
uint bon;
uint public bonus;
enum Stages {
NOTSTARTED,
POSTICO,
PAUSED,
ENDED
} | 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 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 StandardToken is ERC20 {
using SafeMath for uint;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
} | 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;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
} | 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 {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.