contract_name stringlengths 1 61 | file_path stringlengths 5 50.4k | contract_address stringlengths 42 42 | language stringclasses 1
value | class_name stringlengths 1 61 | class_code stringlengths 4 330k | class_documentation stringlengths 0 29.1k | class_documentation_type stringclasses 6
values | func_name stringlengths 0 62 | func_code stringlengths 1 303k | func_documentation stringlengths 2 14.9k | func_documentation_type stringclasses 4
values | compiler_version stringlengths 15 42 | license_type stringclasses 14
values | swarm_source stringlengths 0 71 | meta dict | __index_level_0__ int64 0 60.4k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | exists | function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
| /**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existence of
* @return whether the token exists
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
3276,
3422
]
} | 3,007 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | approve | function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
| /**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given t... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
3834,
4121
]
} | 3,008 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | getApproved | function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
| /**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
4352,
4468
]
} | 3,009 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | setApprovalForAll | function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
| /**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
4753,
4965
]
} | 3,010 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | isApprovedForAll | function isApprovedForAll(
address _owner,
address _operator
)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
| /**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
5279,
5459
]
} | 3,011 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | transferFrom | function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
canTransfer(_tokenId)
{
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _to... | /**
* @dev Transfers the ownership of a given token ID to another address
* Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
5884,
6245
]
} | 3,012 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | safeTransferFrom | function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
canTransfer(_tokenId)
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
| /**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
6872,
7110
]
} | 3,013 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | safeTransferFrom | function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
| /**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
7803,
8120
]
} | 3,014 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | isApprovedOrOwner | function isApprovedOrOwner(
address _spender,
uint256 _tokenId
)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (
_spender ... | /**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
8473,
8931
]
} | 3,015 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | _mint | function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
| /**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
9185,
9361
]
} | 3,016 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | _burn | function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
| /**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
9551,
9746
]
} | 3,017 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | clearApproval | function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
}
}
| /**
* @dev Internal function to clear current approval of a given token ID
* Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
10013,
10235
]
} | 3,018 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | addTokenTo | function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
| /**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
10502,
10713
]
} | 3,019 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | removeTokenFrom | function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
| /**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
10996,
11217
]
} | 3,020 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | checkAndCallSafeTransfer | function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(
msg.sender, _from, _tokenId, _data);
return (retval == ERC721_R... | /**
* @dev Internal function to invoke `onERC721Received` on a target address
* The call is not executed if the target address is not a contract
* @param _from address representing the previous owner of the given token ID
* @param _to target address that will receive the tokens
* @param _tokenId uint256 ID of... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
11731,
12096
]
} | 3,021 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | name | function name() external view returns (string) {
return name_;
}
| /**
* @dev Gets the token name
* @return string representing the token name
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1637,
1712
]
} | 3,022 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | symbol | function symbol() external view returns (string) {
return symbol_;
}
| /**
* @dev Gets the token symbol
* @return string representing the token symbol
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1813,
1892
]
} | 3,023 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | tokenURI | function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
| /**
* @dev Returns an URI for a given token ID
* Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
2084,
2223
]
} | 3,024 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
| /**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
2589,
2805
]
} | 3,025 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | totalSupply | function totalSupply() public view returns (uint256) {
return allTokens.length;
}
| /**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
2950,
3042
]
} | 3,026 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | tokenByIndex | function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
| /**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
3371,
3517
]
} | 3,027 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | _setTokenURI | function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
| /**
* @dev Internal function to set the token URI for a given token
* Reverts if the token ID does not exist
* @param _tokenId uint256 ID of the token to set its URI
* @param _uri string URI to assign
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
3747,
3883
]
} | 3,028 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | addTokenTo | function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
| /**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
4150,
4384
]
} | 3,029 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | removeTokenFrom | function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenInde... | /**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
4667,
5542
]
} | 3,030 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | _mint | function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
| /**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to address the beneficiary that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
5808,
5988
]
} | 3,031 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('t... | _burn | function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex ... | /**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _owner owner of the token to burn
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
6225,
6832
]
} | 3,032 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareToken | contract CryptoCareToken is ERC721Token, Ownable, Pausable {
event TokenURIUpdated(uint256 _tokenID, string _tokenURI);
address public minterAddress;
constructor() public ERC721Token("CryptoCare", "CARE") {}
/**
* @dev Throws if called by any account other than the minter.
*/
mo... | mintToken | function mintToken(address _to, string _tokenURI) public onlyMinter whenNotPaused returns (uint256) {
uint256 newTokenId = _getNextTokenId();
_mint(_to, newTokenId);
_setTokenURI(newTokenId, _tokenURI);
return newTokenId;
}
| /**
* @dev Mints a new token with given tokenURI for an address
* @param _to the address to mint the token to
* @param _tokenURI the token URI containing the token metadata
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
612,
883
]
} | 3,033 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareToken | contract CryptoCareToken is ERC721Token, Ownable, Pausable {
event TokenURIUpdated(uint256 _tokenID, string _tokenURI);
address public minterAddress;
constructor() public ERC721Token("CryptoCare", "CARE") {}
/**
* @dev Throws if called by any account other than the minter.
*/
mo... | updateTokenURI | function updateTokenURI(uint256 _tokenID, string _tokenURI) public onlyMinter whenNotPaused {
_setTokenURI(_tokenID, _tokenURI);
emit TokenURIUpdated(_tokenID, _tokenURI);
}
| /**
* @dev Updates the token URI for a given token ID
* @param _tokenID the token ID to update
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1004,
1205
]
} | 3,034 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareToken | contract CryptoCareToken is ERC721Token, Ownable, Pausable {
event TokenURIUpdated(uint256 _tokenID, string _tokenURI);
address public minterAddress;
constructor() public ERC721Token("CryptoCare", "CARE") {}
/**
* @dev Throws if called by any account other than the minter.
*/
mo... | updateMinter | function updateMinter(address _addr) public onlyOwner whenNotPaused {
require(_addr > 0);
minterAddress = _addr;
}
| /**
* @dev Updates the minter address
* @param _addr the new minter address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1307,
1449
]
} | 3,035 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareToken | contract CryptoCareToken is ERC721Token, Ownable, Pausable {
event TokenURIUpdated(uint256 _tokenID, string _tokenURI);
address public minterAddress;
constructor() public ERC721Token("CryptoCare", "CARE") {}
/**
* @dev Throws if called by any account other than the minter.
*/
mo... | _getNextTokenId | function _getNextTokenId() private view returns (uint256) {
return totalSupply().add(1);
}
| /**
* @dev calculates the next token ID based on totalSupply
* @return uint256 for the next token ID
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1576,
1685
]
} | 3,036 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | mintTo | function mintTo(
address _to, uint8 _beneficiaryId, string _tokenURI, uint256 _nonce, uint8 _rate, uint8 v, bytes32 r, bytes32 s
) public payable whenNotPaused returns (uint256) {
require(msg.value > 0);
require(!usedNonces[_nonce]);
require(beneficiaries[_beneficiaryId].addr > 0);
require(ben... | /**
* @dev Mints a token to an address with a tokenURI
* and sends funds to beneficiary specified
* @param _to address of the future owner of the token
* @param _beneficiaryId the id in beneficiaryAddresses to send the money to
* @param _tokenURI token URI for the token metadata
* @param _nonce n... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1176,
2001
]
} | 3,037 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | addBeneficiary | function addBeneficiary(uint8 beneficiaryId, address addr) public onlyOwner {
require(beneficiaries[beneficiaryId].addr == 0);
beneficiaries[beneficiaryId] = beneficiaryInfo(addr, true, 0);
emit BeneficiaryAdded(beneficiaryId, addr);
}
| /**
* @dev Adds a beneficiary to the mapping
* @param beneficiaryId the identifier for the beneficiary address
* @param addr the address of the beneficiary
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
2188,
2460
]
} | 3,038 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | activateBeneficiary | function activateBeneficiary(uint8 beneficiaryId) public onlyOwner {
require(beneficiaries[beneficiaryId].addr > 0);
require(!beneficiaries[beneficiaryId].isActive);
beneficiaries[beneficiaryId].isActive = true;
emit BeneficiaryActivated(beneficiaryId);
}
| /**
* @dev Activates an existing beneficiary in the mapping
* @param beneficiaryId the identifier for the beneficiary address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
2612,
2915
]
} | 3,039 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | deactivateBeneficiary | function deactivateBeneficiary(uint8 beneficiaryId) public onlyOwner {
require(beneficiaries[beneficiaryId].addr > 0);
require(beneficiaries[beneficiaryId].isActive);
beneficiaries[beneficiaryId].isActive = false;
emit BeneficiaryDeactivated(beneficiaryId);
}
| /**
* @dev Deactivates a beneficiary from the mapping
* @param beneficiaryId the identifier for the beneficiary address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
3061,
3368
]
} | 3,040 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | updateMinter | function updateMinter(address _addr) public onlyOwner {
require(_addr > 0);
minterAddress = _addr;
}
| /**
* @dev Updates the minter address
* @param _addr the new minter address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
3470,
3598
]
} | 3,041 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | updateTokenContract | function updateTokenContract(address _tokenContractAddress) public onlyOwner {
tokenContract = CryptoCareToken(_tokenContractAddress);
}
| /**
* @dev Updates the token contract address
* @param _tokenContractAddress the new token contract address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
3732,
3887
]
} | 3,042 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | updateOverrideRate | function updateOverrideRate(bool _active, uint8 _rate) public onlyOwner {
require(_rate < 100);
overrideRateActive = _active;
overrideRate = _rate;
}
| /**
* @dev Updates override rate and if it is active
* @param _active whether the override is active or not
* @param _rate the new override rate
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
4063,
4249
]
} | 3,043 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | withdraw | function withdraw() public onlyOwner {
owner.transfer(address(this).balance);
}
| /**
* @dev Allows owner to withdraw funds in contract
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
4324,
4422
]
} | 3,044 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | verifyMessage | function verifyMessage(bytes32 h, uint8 v, bytes32 r, bytes32 s) private view returns (bool) {
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHash = keccak256(abi.encodePacked(prefix, h));
address addr = ecrecover(prefixedHash, v, r, s);
bool verified = (addr == minterAddr... | /**
* @dev Verifies a given hash and ECDSA signature match the minter address
* @param h to verify
* @param v ECDSA signature parameter
* @param r ECDSA signature parameter
* @param s ECDSA signature parameter
* @return bool whether the hash was signed by the minter
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
5074,
5453
]
} | 3,045 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | CryptoCareMinter | contract CryptoCareMinter is Ownable, Pausable {
event Adoption(uint256 tokenId, address indexed toAddress, string tokenURI, uint8 beneficiaryId, uint256 price, uint8 rate);
event BeneficiaryAdded(uint8 beneficiaryId, address addr);
event BeneficiaryRateUpdated(uint8 beneficiaryId, uint8 rate);
ev... | transferToBeneficiary | function transferToBeneficiary(uint256 amount, uint8 _beneficiaryId, uint8 _rate) private {
beneficiaryInfo storage beneficiary = beneficiaries[_beneficiaryId];
uint8 rate = overrideRateActive ? overrideRate : _rate;
uint256 beneficiaryTotal = (amount * (100 - rate))/100;
beneficiary.addr.transfer... | /**
* @dev Transfers amount to beneficiary
* @param amount the amount to transfer
* @param _beneficiaryId the beneficiary to receive it
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
5620,
6035
]
} | 3,046 | |||
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
199,
287
]
} | 3,047 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
T... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
445,
836
]
} | 3,048 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
1042,
1154
]
} | 3,049 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | 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[_... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
401,
853
]
} | 3,050 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* ... | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
1485,
1675
]
} | 3,051 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
1999,
2130
]
} | 3,052 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
2596,
2860
]
} | 3,053 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
3331,
3741
]
} | 3,054 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | Ownable | function Ownable() public {
owner = msg.sender;
}
| /**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
261,
321
]
} | 3,055 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
640,
816
]
} | 3,056 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | MintableToken | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that ... | /**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/ | NatSpecMultiLine | mint | function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
| /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
483,
756
]
} | 3,057 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | MintableToken | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that ... | /**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/ | NatSpecMultiLine | finishMinting | function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
| /**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
873,
1015
]
} | 3,058 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function ... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | pause | function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
| /**
* @dev called by the owner to pause, triggers stopped state
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
513,
604
]
} | 3,059 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function ... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | unpause | function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
| /**
* @dev called by the owner to unpause, returns to normal state
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
688,
781
]
} | 3,060 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | ICO | contract ICO is Ownable {
using SafeMath for uint256;
// The token being sold
Token public token;
uint public MINIMUMCONTIB = 0.01 ether;
// start and end timestamps where investments are allowed (both inclusive) ICO
uint256 public startTimeIco;
uint256 public endTimeIco;
... | /**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH baseRate. Funds collected are forwarded to a wallet
* as th... | NatSpecMultiLine | function () public payable {
require(msg.value >= MINIMUMCONTIB);
if (validPurchaseIco(msg.value)) {
buyTokensIco(msg.sender);
} else {
require(false);
}
}
| // fallback function can be used to buy tokens or participate in pre-ico | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
2477,
2704
]
} | 3,061 | ||
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | ICO | contract ICO is Ownable {
using SafeMath for uint256;
// The token being sold
Token public token;
uint public MINIMUMCONTIB = 0.01 ether;
// start and end timestamps where investments are allowed (both inclusive) ICO
uint256 public startTimeIco;
uint256 public endTimeIco;
... | /**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH baseRate. Funds collected are forwarded to a wallet
* as th... | NatSpecMultiLine | getRateIco | function getRateIco() public constant returns (uint256) {
if(now > endTimeIco)
return 0;
else {
return baseRate;
}
}
| // function to get current rate for ICO purchases | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
3106,
3290
]
} | 3,062 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | ICO | contract ICO is Ownable {
using SafeMath for uint256;
// The token being sold
Token public token;
uint public MINIMUMCONTIB = 0.01 ether;
// start and end timestamps where investments are allowed (both inclusive) ICO
uint256 public startTimeIco;
uint256 public endTimeIco;
... | /**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH baseRate. Funds collected are forwarded to a wallet
* as th... | NatSpecMultiLine | buyTokensIco | function buyTokensIco(address _beneficiary) internal {
require(_beneficiary != 0x0);
// calculate token amount to be created
uint256 rate = getRateIco();
uint256 tokens = msg.value.mul(10 ** 18).div(rate);
// update state
weiRaised = weiRaised.add(msg.value);
tokensIssuedIco = tok... | // low level token purchase function | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
3335,
3913
]
} | 3,063 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | ICO | contract ICO is Ownable {
using SafeMath for uint256;
// The token being sold
Token public token;
uint public MINIMUMCONTIB = 0.01 ether;
// start and end timestamps where investments are allowed (both inclusive) ICO
uint256 public startTimeIco;
uint256 public endTimeIco;
... | /**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH baseRate. Funds collected are forwarded to a wallet
* as th... | NatSpecMultiLine | forwardFunds | function forwardFunds() internal {
wallet.transfer(msg.value);
}
| // send ether to the fund collection wallet | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
3965,
4048
]
} | 3,064 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | ICO | contract ICO is Ownable {
using SafeMath for uint256;
// The token being sold
Token public token;
uint public MINIMUMCONTIB = 0.01 ether;
// start and end timestamps where investments are allowed (both inclusive) ICO
uint256 public startTimeIco;
uint256 public endTimeIco;
... | /**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH baseRate. Funds collected are forwarded to a wallet
* as th... | NatSpecMultiLine | validPurchaseIco | function validPurchaseIco(uint256 _amount) public constant returns (bool) {
bool withinPeriod = now >= startTimeIco && now <= endTimeIco;
bool nonZeroPurchase = _amount != 0;
return withinPeriod && nonZeroPurchase;
}
| // @return true if the transaction can buy tokens from ICO | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
4115,
4368
]
} | 3,065 | |
ICO | ICO.sol | 0x2d50de5411731843c84232fa7eb807bee7befdf4 | Solidity | ICO | contract ICO is Ownable {
using SafeMath for uint256;
// The token being sold
Token public token;
uint public MINIMUMCONTIB = 0.01 ether;
// start and end timestamps where investments are allowed (both inclusive) ICO
uint256 public startTimeIco;
uint256 public endTimeIco;
... | /**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH baseRate. Funds collected are forwarded to a wallet
* as th... | NatSpecMultiLine | hasEndedIco | function hasEndedIco() internal constant returns (bool) {
return now > endTimeIco;
}
| // @return true if ICO event has ended | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://bed2419233d53309da73c842e71d06bbcf6d6643f3f4878c98aaef9867e47bd2 | {
"func_code_index": [
4415,
4518
]
} | 3,066 | |
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
94,
154
]
} | 3,067 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
237,
310
]
} | 3,068 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
534,
616
]
} | 3,069 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
895,
983
]
} | 3,070 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
1647,
1726
]
} | 3,071 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
2039,
2141
]
} | 3,072 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
259,
445
]
} | 3,073 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
723,
864
]
} | 3,074 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
1162,
1359
]
} | 3,075 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
1613,
2089
]
} | 3,076 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
2560,
2697
]
} | 3,077 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
3188,
3471
]
} | 3,078 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
3931,
4066
]
} | 3,079 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
4546,
4717
]
} | 3,080 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | isContract | function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codeha... | /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
606,
1230
]
} | 3,081 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address... | /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `tr... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
2160,
2562
]
} | 3,082 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCall | function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
| /**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw ... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
3318,
3496
]
} | 3,083 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCall | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
3721,
3922
]
} | 3,084 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
4292,
4523
]
} | 3,085 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
4774,
5095
]
} | 3,086 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
497,
581
]
} | 3,087 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
1139,
1292
]
} | 3,088 | ||
LilDoge | LilDoge.sol | 0xec4d32e3e3374730e0cfe0330449d5c617d340f3 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://7abe1f8d50f29794b09e56eb757635e3e66cdfd7f94ae6e2b86f6c21879fbf44 | {
"func_code_index": [
1442,
1691
]
} | 3,089 | ||
ELCToken | ELCToken.sol | 0x84a265d071c6c33d8b7a784a5fd516eb0080ee26 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) ret... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.13+commit.fb4cb1a | bzzr://8d044facdbf1c661ef6142480d830255d1c49c379a69ee5bf0999674cb2693c1 | {
"func_code_index": [
268,
606
]
} | 3,090 | |
ELCToken | ELCToken.sol | 0x84a265d071c6c33d8b7a784a5fd516eb0080ee26 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) ret... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.13+commit.fb4cb1a | bzzr://8d044facdbf1c661ef6142480d830255d1c49c379a69ee5bf0999674cb2693c1 | {
"func_code_index": [
812,
921
]
} | 3,091 | |
ELCToken | ELCToken.sol | 0x84a265d071c6c33d8b7a784a5fd516eb0080ee26 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_to != address(0));
var _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// require (_value <= _allowance);
balan... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.13+commit.fb4cb1a | bzzr://8d044facdbf1c661ef6142480d830255d1c49c379a69ee5bf0999674cb2693c1 | {
"func_code_index": [
392,
930
]
} | 3,092 | |
ELCToken | ELCToken.sol | 0x84a265d071c6c33d8b7a784a5fd516eb0080ee26 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs... | /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/ | NatSpecMultiLine | v0.4.13+commit.fb4cb1a | bzzr://8d044facdbf1c661ef6142480d830255d1c49c379a69ee5bf0999674cb2693c1 | {
"func_code_index": [
1166,
1714
]
} | 3,093 | |
ELCToken | ELCToken.sol | 0x84a265d071c6c33d8b7a784a5fd516eb0080ee26 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.13+commit.fb4cb1a | bzzr://8d044facdbf1c661ef6142480d830255d1c49c379a69ee5bf0999674cb2693c1 | {
"func_code_index": [
2038,
2176
]
} | 3,094 | |
ELCToken | ELCToken.sol | 0x84a265d071c6c33d8b7a784a5fd516eb0080ee26 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/ | NatSpecMultiLine | v0.4.13+commit.fb4cb1a | bzzr://8d044facdbf1c661ef6142480d830255d1c49c379a69ee5bf0999674cb2693c1 | {
"func_code_index": [
2421,
2692
]
} | 3,095 | |
ELCToken | ELCToken.sol | 0x84a265d071c6c33d8b7a784a5fd516eb0080ee26 | Solidity | ELCToken | contract ELCToken is StandardToken {
string public constant name = "ElearningCoin";
string public constant symbol = "ELC";
uint8 public constant decimals = 18; // only two deciminals, token cannot be divided past 1/100th
uint256 public constant INITIAL_SUPPLY = 2000000000000000000000000000; // 2 billion... | /**
* @title ELCToken
*/ | NatSpecMultiLine | ELCToken | function ELCToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| /**
* @dev Contructor that gives msg.sender all of existing tokens.
*/ | NatSpecMultiLine | v0.4.13+commit.fb4cb1a | bzzr://8d044facdbf1c661ef6142480d830255d1c49c379a69ee5bf0999674cb2693c1 | {
"func_code_index": [
420,
528
]
} | 3,096 | |
AaveMonitorV2 | contracts/interfaces/CTokenInterface.sol | 0xcfd05bebb84787ee2efb2ea633981e44d754485d | Solidity | CTokenInterface | abstract contract CTokenInterface is ERC20 {
function mint(uint256 mintAmount) external virtual returns (uint256);
// function mint() external virtual payable;
function accrueInterest() public virtual returns (uint);
function redeem(uint256 redeemTokens) external virtual returns (uint256);
funct... | accrueInterest | function accrueInterest() public virtual returns (uint);
| // function mint() external virtual payable; | LineComment | v0.6.12+commit.27d51765 | MIT | ipfs://285ff2512c6d59b899e93c3b1f893c007ccddbbaccb0949a28275f2880f4f0ca | {
"func_code_index": [
170,
230
]
} | 3,097 | ||
LandWorks | contracts/libraries/LibDiamond.sol | 0x678d837fa15eba2b59f6cd5f9f4c580ac2dfc269 | Solidity | LibDiamond | library LibDiamond {
bytes32 constant DIAMOND_STORAGE_POSITION = keccak256("com.enterdao.landworks.storage");
struct FacetAddressAndPosition {
address facetAddress;
uint96 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array
}
struct FacetFunctionSel... | diamondCut | function diamondCut(
IDiamondCut.FacetCut[] memory _diamondCut,
address _init,
bytes memory _calldata
) internal {
for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {
IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;
if (action == IDiamondCut.Facet... | // Internal function version of diamondCut | LineComment | v0.8.10+commit.fc410830 | {
"func_code_index": [
1471,
2542
]
} | 3,098 | ||||
DONOTFCKINGMINT | DONOTFCKINGMINT.sol | 0xc39fae1822b03791e862231d8b7025d9efca82b5 | Solidity | DONOTFCKINGMINT | contract DONOTFCKINGMINT is ERC721, Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
using Strings for uint256;
Counters.Counter private tokenSupply;
uint256 public constant MAX_SUPPLY = 10000;
uint256 private THE_FCKING_PRICE = 0 ether;
string public... | GETFCKINGPRICE | function GETFCKINGPRICE(uint256 _quantity) public view returns (uint256)
{
uint256 returnPrice;
if (tokenSupply.current().add(_quantity) > 1000)
{
returnPrice = 0.05 ether;
}
return returnPrice;
}
| /********************************
* GET THE CURRENT FCKING PRICE *
********************************/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | None | ipfs://177095c1fa0f4f285de800dc4e7aee31d8565e135830c2377e21ac18c9274b15 | {
"func_code_index": [
1403,
1676
]
} | 3,099 | ||
DONOTFCKINGMINT | DONOTFCKINGMINT.sol | 0xc39fae1822b03791e862231d8b7025d9efca82b5 | Solidity | DONOTFCKINGMINT | contract DONOTFCKINGMINT is ERC721, Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
using Strings for uint256;
Counters.Counter private tokenSupply;
uint256 public constant MAX_SUPPLY = 10000;
uint256 private THE_FCKING_PRICE = 0 ether;
string public... | DO_NOT_FCKING_CALL_THIS_MINT_FUNCTION | function DO_NOT_FCKING_CALL_THIS_MINT_FUNCTION(uint256 _quantity) external payable
{
require(mintActive, "WE'RE NOT FCKING MINTING");
_FCKINGSAFEMINT(_quantity);
}
| /******************************
* 1-1000 FCKING FREE *
* 1001-10000 FCKING .05 ETH *
******************************/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | None | ipfs://177095c1fa0f4f285de800dc4e7aee31d8565e135830c2377e21ac18c9274b15 | {
"func_code_index": [
2149,
2348
]
} | 3,100 | ||
Timelock | @openzeppelin/contracts/math/SafeMath.sol | 0x5afedef12b556bd7deb056dd2aba5e084a5a0c2f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
r... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | tryAdd | function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
| /**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f306e547a554f3783f677542a35ad719674495db1d7a807923393667c52ecb7e | {
"func_code_index": [
161,
344
]
} | 3,101 |
Timelock | @openzeppelin/contracts/math/SafeMath.sol | 0x5afedef12b556bd7deb056dd2aba5e084a5a0c2f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
r... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | trySub | function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
| /**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f306e547a554f3783f677542a35ad719674495db1d7a807923393667c52ecb7e | {
"func_code_index": [
492,
651
]
} | 3,102 |
Timelock | @openzeppelin/contracts/math/SafeMath.sol | 0x5afedef12b556bd7deb056dd2aba5e084a5a0c2f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
r... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | tryMul | function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0)... | /**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f306e547a554f3783f677542a35ad719674495db1d7a807923393667c52ecb7e | {
"func_code_index": [
801,
1249
]
} | 3,103 |
Timelock | @openzeppelin/contracts/math/SafeMath.sol | 0x5afedef12b556bd7deb056dd2aba5e084a5a0c2f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
r... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | tryDiv | function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
| /**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f306e547a554f3783f677542a35ad719674495db1d7a807923393667c52ecb7e | {
"func_code_index": [
1400,
1560
]
} | 3,104 |
Timelock | @openzeppelin/contracts/math/SafeMath.sol | 0x5afedef12b556bd7deb056dd2aba5e084a5a0c2f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
r... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | tryMod | function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
| /**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f306e547a554f3783f677542a35ad719674495db1d7a807923393667c52ecb7e | {
"func_code_index": [
1721,
1881
]
} | 3,105 |
Timelock | @openzeppelin/contracts/math/SafeMath.sol | 0x5afedef12b556bd7deb056dd2aba5e084a5a0c2f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
r... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://f306e547a554f3783f677542a35ad719674495db1d7a807923393667c52ecb7e | {
"func_code_index": [
2123,
2307
]
} | 3,106 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.