function
string | label
int64 |
|---|---|
function transferOwnership(address newOwner) onlyOwner public{
require(newOwner != address(0));
owner = newOwner;
}
| 0
|
function _burn(address _account, uint256 _amount) internal {
require(_account != 0, "Address must not be zero");
require(_amount <= balances[_account], "Insuficient funds");
totalSupply_ = totalSupply_.sub(_amount);
balances[_account] = balances[_account].sub(_amount);
emit Transfer(_account, address(0), _amount);
emit Burn(_account, _amount);
}
| 0
|
constructor () internal {
_owner = 0xfc0281163cFeDA9FbB3B18A72A27310B1725fD65;
emit OwnershipTransferred(address(0), _owner);
}
| 0
|
function buyTokens(address investor) public payable {
require(investor != address(0));
require(now >= startTime && now <= endTime);
require(crowdsaleActive);
require(msg.value != 0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
require(tokensSold.add(tokens) <= goal);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
balances[investor] = balances[investor].add(weiAmount);
assert(token.transferFrom(tokenOwner, investor, tokens));
TokenPurchase(msg.sender, investor, weiAmount, tokens);
wallet.transfer(msg.value);
}
| 0
|
function approve(address spender, uint256 value) public returns (bool);
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
}
| 0
|
function burn(uint256 value) public {
_burn(msg.sender, value);
}
| 0
|
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, 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 ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
| 0
|
function depositEther(address account) external payable {
emit Deposit(0, account, msg.value);
addBalance(0, account, msg.value);
}
| 0
|
function allowance(address _owner, address _spender)
public
view
returns (uint256 remaining)
{
if (_spender != owner) {
return allowed[_owner][_spender];
}
uint256 unlockedTokens;
uint256 spentTokens;
if (_owner == teamAllocation) {
unlockedTokens = _calculateUnlockedTokens(
teamCliff, teamUnlockedAfterCliff,
teamPeriodLength, teamPeriodAmount, teamPeriodsNumber
);
spentTokens = balanceOf(teamAllocation) < teamTotal ? teamTotal.sub(balanceOf(teamAllocation)) : 0;
} else if (_owner == advisorsAllocation) {
unlockedTokens = _calculateUnlockedTokens(
advisorsCliff, advisorsUnlockedAfterCliff,
advisorsPeriodLength, advisorsPeriodAmount, advisorsPeriodsNumber
);
spentTokens = balanceOf(advisorsAllocation) < advisorsTotal ? advisorsTotal.sub(balanceOf(advisorsAllocation)) : 0;
} else {
return allowed[_owner][_spender];
}
return unlockedTokens.sub(spentTokens);
}
| 0
|
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| 0
|
function balanceOf(address sender) public constant returns (uint256)
{
return balances[sender];
}
| 0
|
function hasSaleBeginTimeCome() public view returns(bool) {
return (block.timestamp > saleBeginTime);
}
| 0
|
function getCurrentTimestamp() internal returns (uint256) {
return now;
}
| 1
|
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 _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
bool withinPeriod = now >= presaleStartTime && now <= endTime;
bool atLeastMinimumAmount = false;
if(block.timestamp <= startTime) {
require(_weiAmount.add(weiRaised.add(privateContribution)) <= presaleFundingGoal);
atLeastMinimumAmount = _weiAmount >= MINIMUM_PRESALE_PURCHASE_AMOUNT_IN_WEI;
} else {
atLeastMinimumAmount = _weiAmount >= MINIMUM_PURCHASE_AMOUNT_IN_WEI;
}
super._preValidatePurchase(_beneficiary, _weiAmount);
require(msg.sender == _beneficiary);
require(_weiAmount.add(weiRaised.add(privateContribution)) <= fundingGoal);
require(withinPeriod);
require(atLeastMinimumAmount);
require(crowdsaleActive);
}
| 0
|
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);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function getExchangeContract() external view returns (address);
function contractApproved(address traderAddr) external view returns (bool);
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
}
| 0
|
function issueTokens(address _to, uint256 _amount) public onlyOwner
{
require(_to != 0x0);
this.transfer(_to, _amount);
}
| 0
|
function maximumProfit()
public
view
returns(uint256)
{
return pot / MAX_PROFIT_DIVISOR;
}
| 0
|
function requestOracleValue() public view onlyOwner returns(bytes32) {
return oracle.current();
}
| 0
|
function play()
public
payable
validBet
onlyPlayer
{
require(tickets[msg.sender].block_number == 0);
require(ticketIndex.length < 200);
tickets[msg.sender].is_winner = false;
tickets[msg.sender].is_active = true;
tickets[msg.sender].block_number = block.number;
tickets[msg.sender].block_time = block.timestamp;
tickets[msg.sender].num_votes = 0;
ticketIndex.push(msg.sender);
NewPlayerAdded(ticketIndex.length, getPrizeAmount());
}
| 1
|
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract NXX is ERC223, Pausable {
using SafeMath for uint256;
using ContractLib for address;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
function NXX() public {
symbol = "NASHXX";
name = "XXXX CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
| 0
|
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
}
| 1
|
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 ShortAddressProtection {
modifier onlyPayloadSize(uint256 numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
}
| 0
|
function lessThanMaxRatio(address beneficiary, uint256 amount, Day storage today) internal view returns (bool) {
uint256 boughtTodayBefore = today.fuelBoughtByAddress[beneficiary];
return boughtTodayBefore.add(amount).mul(100).div(maximumPercentageOfDaysSupply) <= today.supply;
}
| 0
|
function approve(address _spender, uint256 _value) external returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| 1
|
function transfer(address _to, uint256 _amount) public returns (bool) {
_transfer(msg.sender, _to, _amount);
return true;
}
| 0
|
function balanceOf(address sender) public constant returns(uint256 balance) {
return balances[sender];
}
| 0
|
function max256(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
}
| 0
|
function transfer(address _to, uint256 _value, bytes _data) onlyPayloadSize(3 * 32) public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.