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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T2 | contract T2 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _safeMint | function _safeMint(address to, uint256 tokenId) private {
_safeMint(to, tokenId, "");
}
| /**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
d*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
13271,
13377
]
} | 12,900 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T2 | contract T2 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _safeMint | function _safeMint(address to, uint256 tokenId, bytes memory _data) private {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
| /**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
13599,
13845
]
} | 12,901 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T2 | contract T2 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _mint | function _mint(address to, uint256 tokenId) private {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(address(0), to, tokenId);
}
| /**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
14176,
14518
]
} | 12,902 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T2 | contract T2 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _burn | function _burn(uint256 tokenId) internal virtual {
address owner = ownerOf(tokenId);
// Clear approvals
_approve(address(0), tokenId);
_holderTokens[owner].remove(tokenId);
_tokenOwners.remove(tokenId);
emit Transfer(owner, address(0), tokenId);
}
| /**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
14742,
15057
]
} | 12,903 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T2 | contract T2 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 tokenId) private {
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
require(_transferable == true, "ERC721 transfer not permitted by contract owner");
... | /**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - contract owner must have transfer globally allowed.
*
* Emits a {... | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
15451,
16061
]
} | 12,904 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T2 | contract T2 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _checkOnERC721Received | function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes memory returndata = to.functionCall(abi.encodeWithSelector(
IERC721Receiver(to).onERC721Received.selector,
_msgS... | /**
* @dev Internal function to invoke {IERC721Receiver-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 to... | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
16621,
17221
]
} | 12,905 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length();
}
| /**
* @dev See {IERC721-balanceOf}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
4516,
4736
]
} | 12,906 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | ownerOf | function ownerOf(uint256 tokenId) public view override returns (address) {
return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
}
| /**
* @dev See {IERC721-ownerOf}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
4793,
4967
]
} | 12,907 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | name | function name() external view override returns (string memory) {
return _name;
}
| /**
* @dev See {IERC721Metadata-name}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
5029,
5128
]
} | 12,908 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | symbol | function symbol() external view override returns (string memory) {
return _symbol;
}
| /**
* @dev See {IERC721Metadata-symbol}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
5192,
5295
]
} | 12,909 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | tokenURI | function tokenURI(uint256 tokenId) external view override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
// If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
return string(abi.encodePacked(_baseURI, tokenId.toString()... | /**
* @dev See {IERC721Metadata-tokenURI}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
5361,
5708
]
} | 12,910 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | baseURI | function baseURI() external view returns (string memory) {
return _baseURI;
}
| /**
* @dev Returns the base URI set via {_setBaseURI}. This will be
* automatically added as a prefix in {tokenURI} to each token's URI, or
* to the token ID if no specific URI is set for that token ID.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
5942,
6038
]
} | 12,911 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | ticketContract | function ticketContract() external view returns (address) {
return _ticketContract;
}
| /**
* @dev Retrieves address of the ticket token contract.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
6120,
6224
]
} | 12,912 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | tokenPrice | function tokenPrice() external view returns (uint256) {
return _tokenPrice;
}
| /**
* @dev Price per token for public purchase.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
6295,
6391
]
} | 12,913 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | nextTokenId | function nextTokenId() public view returns (uint256) {
return _nextId;
}
| /**
* @dev Next token id.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
6440,
6531
]
} | 12,914 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index) external view override returns (uint256) {
require(index < balanceOf(owner), "Invalid token index for holder");
return _holderTokens[owner].at(index);
}
| /**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
6610,
6849
]
} | 12,915 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view override returns (uint256) {
// _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
return _tokenOwners.length();
}
| /**
* @dev See {IERC721Enumerable-totalSupply}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
6920,
7130
]
} | 12,916 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | supplyOfA | function supplyOfA() external view returns (uint256) {
return _countA;
}
| /**
* @dev Supply of A tokens.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
7184,
7275
]
} | 12,917 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 index) external view override returns (uint256) {
require(index < _tokenOwners.length(), "Invalid token index");
(uint256 tokenId, ) = _tokenOwners.at(index);
return tokenId;
}
| /**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
7347,
7590
]
} | 12,918 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | approve | function approve(address to, uint256 tokenId) external virtual override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for a... | /**
* @dev See {IERC721-approve}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
7647,
8044
]
} | 12,919 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | getApproved | function getApproved(uint256 tokenId) public view override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
| /**
* @dev See {IERC721-getApproved}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
8105,
8323
]
} | 12,920 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | setApprovalForAll | function setApprovalForAll(address operator, bool approved) external virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
| /**
* @dev See {IERC721-setApprovalForAll}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
8390,
8692
]
} | 12,921 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | isApprovedForAll | function isApprovedForAll(address owner, address operator) public view override returns (bool) {
return _operatorApprovals[owner][operator];
}
| /**
* @dev See {IERC721-isApprovedForAll}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
8758,
8919
]
} | 12,922 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address from, address to, uint256 tokenId) external virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
| /**
* @dev See {IERC721-transferFrom}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
8981,
9293
]
} | 12,923 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId) external virtual override {
safeTransferFrom(from, to, tokenId, "");
}
| /**
* @dev See {IERC721-safeTransferFrom}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
9359,
9517
]
} | 12,924 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
| /**
* @dev See {IERC721-safeTransferFrom}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
9583,
9873
]
} | 12,925 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | buyToken | function buyToken() external payable returns (bool)
{
uint256 paidAmount = msg.value;
require(paidAmount == _tokenPrice, "Invalid amount for token purchase");
address to = msg.sender;
uint256 nextToken = nextTokenId();
uint256 remainingTokens = 1 + MAX_SUPPLY - nextToken;
require(remainin... | /**
* @dev Buys a token. Needs to be supplied the correct amount of ether.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
9971,
11092
]
} | 12,926 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | isA | function isA(uint256 tokenId) external view returns (bool) {
require(_exists(tokenId), "Token ID does not exist");
return _additionalData[tokenId].isA;
}
| /**
* @dev Retrieves if the specified token is of A type.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
12615,
12796
]
} | 12,927 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | someBool | function someBool(uint256 tokenId) external view returns (bool) {
require(_exists(tokenId), "Token ID does not exist");
return _additionalData[tokenId].someBool;
}
| /**
* @dev Retrieves if the specified token has its someBool attribute set.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
12895,
13086
]
} | 12,928 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | setSomeBool | function setSomeBool(uint256 tokenId, bool newValue) external {
require(_exists(tokenId), "Token ID does not exist");
require(ownerOf(tokenId) == msg.sender, "Only token owner can set attribute");
require(T2(_ticketContract).burnAnyFrom(msg.sender), "Token owner ticket could not be burned");
_additi... | /**
* @dev Sets someBool for the specified token. Can only be used by the owner of the token (not an approved account).
* Owner needs to also own a ticket token to set the someBool attribute.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
13307,
13693
]
} | 12,929 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | power | function power(uint256 tokenId) external view returns (uint8) {
require(_exists(tokenId), "Token ID does not exist");
return _additionalData[tokenId].power;
}
| /**
* @dev Retrieves the power value for a specified token.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
13776,
13962
]
} | 12,930 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | setBaseURI | function setBaseURI(string calldata baseURI_) external onlyOwner {
_baseURI = baseURI_;
}
| /**
* @dev Function to set the base URI for all token IDs. It is automatically added as a prefix to the token id in {tokenURI} to retrieve the token URI.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
14160,
14268
]
} | 12,931 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | setTokenPrice | function setTokenPrice(uint256 newPrice) external onlyOwner {
_tokenPrice = newPrice;
}
| /**
* @dev Sets a new token price.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
14326,
14432
]
} | 12,932 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _safeTransfer | function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) private {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
| /**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is eq... | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
15333,
15601
]
} | 12,933 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _exists | function _exists(uint256 tokenId) private view returns (bool) {
return tokenId < _nextId && _tokenOwners.contains(tokenId);
}
| /**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`).
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
15851,
15995
]
} | 12,934 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _isApprovedOrOwner | function _isApprovedOrOwner(address spender, uint256 tokenId) private view returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
| /**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
16157,
16494
]
} | 12,935 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 tokenId) private {
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
// Clear approvals from the previous owner
_approve(address(0), tokenId);
... | /**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - contract owner must have transfer globally allowed.
*
* Emits a {... | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
16888,
17406
]
} | 12,936 | ||
NFTeGG_Burner | NFTeGG_Burner.sol | 0x8409a26de50daad783ac7ac1cf91159c1e8fdf21 | Solidity | T1 | contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings... | /**
* @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
*/ | NatSpecMultiLine | _checkOnERC721Received | function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes memory returndata = to.functionCall(abi.encodeWithSelector(
IERC721Receiver(to).onERC721Received.selector,
_msgS... | /**
* @dev Internal function to invoke {IERC721Receiver-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 to... | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
17966,
18566
]
} | 12,937 | ||
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
constructor () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* ... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256 balance) {
return accounts [_owner];
}
| /**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* owner of
* @return number of tokens currently belonging to the owner of given address
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
421,
534
]
} | 12,938 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
constructor () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* ... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
if (accounts [msg.sender] < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
accounts [_to] = safeAdd (accounts [_to]... | /**
* Transfer given number of tokens from message sender to given recipient.
*
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer to the owner of given address
* @return true if tokens were transferred successfully, false otherwise
* accounts [_to] + _value... | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
951,
1370
]
} | 12,939 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
constructor () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* ... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public
returns (bool success) {
require(_to != address(0));
if (allowances [_from][msg.sender] < _value) return false;
if (accounts [_from] < _value) return false;
if (_value > 0 && _from != _to) {
allowances [_from][msg.sender] = safeS... | /**
* Transfer given number of tokens from given owner to given recipient.
*
* @param _from address to transfer tokens from the owner of
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer from given owner to given
* recipient
* @return true if token... | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
1867,
2436
]
} | 12,940 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
constructor () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* ... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | approve | function approve (address _spender, uint256 _value) public returns (bool success) {
allowances [msg.sender][_spender] = _value;
emit Approval (msg.sender, _spender, _value);
return true;
| /**
* Allow given spender to transfer given number of tokens from message sender.
* @param _spender address to allow the owner of to transfer tokens from message sender
* @param _value number of tokens to allow to transfer
* @return true if token transfer was successfully approved, false otherwise
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
2764,
2974
]
} | 12,941 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | AbstractToken | contract AbstractToken is Token, SafeMath {
/**
* Create new Abstract Token contract.
*/
constructor () public {
// Do nothing
}
/**
* Get number of tokens currently belonging to given owner.
*
* @param _owner address to get number of tokens currently belonging to the
* ... | /**
* Abstract Token Smart Contract that could be used as a base contract for
* ERC-20 token contracts.
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view
returns (uint256 remaining) {
return allowances [_owner][_spender];
}
| /**
* Tell how many tokens given spender is currently allowed to transfer from
* given owner.
*
* @param _owner address to get number of tokens allowed to be transferred
* from the owner of
* @param _spender address to get number of tokens allowed to be transferred
* by the owner of
* @ret... | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
3422,
3570
]
} | 12,942 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256 supply) {
return tokenCount;
}
| /**
* Get total number of tokens in circulation.
*
* @return total number of tokens in circulation
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
932,
1025
]
} | 12,943 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool success) {
require(!frozenAccount[msg.sender]);
f (frozen) return false;
else return AbstractToken.transfer (_to, _value);
}
| /**
* Transfer given number of tokens from message sender to given recipient.
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer to the owner of given address
* @return true if tokens were transferred successfully, false otherwise
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
1462,
1673
]
} | 12,944 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public
returns (bool success) {
equire(!frozenAccount[_from]);
if (frozen) return false;
else return AbstractToken.transferFrom (_from, _to, _value);
}
| /**
* Transfer given number of tokens from given owner to given recipient.
*
* @param _from address to transfer tokens from the owner of
* @param _to address to transfer tokens to the owner of
* @param _value number of tokens to transfer from given owner to given
* recipient
* @return true if token... | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
2069,
2310
]
} | 12,945 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | approve | function approve (address _spender, uint256 _value) public
returns (bool success) {
equire(allowance (msg.sender, _spender) == 0 || _value == 0);
return AbstractToken.approve (_spender, _value);
}
| /**
* Change how many tokens given spender is allowed to transfer from message
* spender. In order to prevent double spending of allowance,
* 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 rac... | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
2996,
3211
]
} | 12,946 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | createTokens | function createTokens(uint256 _value) public
returns (bool success) {
require (msg.sender == owner);
if (_value > 0) {
if (_value > safeSub (MAX_TOKEN_COUNT, tokenCount)) return false;
accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
tokenCount = safeAdd (tokenCount, _valu... | /**
* Create _value new tokens and give new created tokens to msg.sender.
* May only be called by smart contract owner.
*
* @param _value number of tokens to create
* @return true if tokens were created successfully, false otherwise
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
3477,
3995
]
} | 12,947 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | setOwner | function setOwner(address _newOwner) public {
require (msg.sender == owner);
owner = _newOwner;
}
| /**
* Set new owner for the smart contract.
* May only be called by smart contract owner.
*
* @param _newOwner address of new owner of the smart contract
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
4182,
4297
]
} | 12,948 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | freezeTransfers | function freezeTransfers () public {
require (msg.sender == owner);
if (!frozen) {
frozen = true;
emit Freeze ();
}
}
| /**
* Freeze ALL token transfers.
* May only be called by smart contract owner.
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
4398,
4552
]
} | 12,949 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | unfreezeTransfers | function unfreezeTransfers () public {
require (msg.sender == owner);
if (frozen) {
frozen = false;
emit Unfreeze ();
}
}
| /**
* Unfreeze ALL token transfers.
* May only be called by smart contract owner.
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
4655,
4813
]
} | 12,950 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | refundTokens | function refundTokens(address _token, address _refund, uint256 _value) public {
require (msg.sender == owner);
require(_token != address(this));
AbstractToken token = AbstractToken(_token);
token.transfer(_refund, _value);
emit RefundTokens(_token, _refund, _value);
}
| /*A user is able to unintentionally send tokens to a contract
* and if the contract is not prepared to refund them they will get stuck in the contract.
* The same issue used to happen for Ether too but new Solidity versions added the payable modifier to
* prevent unintended Ether transfers. However, there’s no ... | Comment | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
5232,
5531
]
} | 12,951 | |
CAEE | CAEE.sol | 0x5df57065865e078e2029f264dca5517ac08601b4 | Solidity | CAEE | contract CAEE is AbstractToken {
/**
* Maximum allowed number of tokens in circulation.
* tokenSupply = tokensIActuallyWant * (10 ^ decimals)
*/
uint256 constant MAX_TOKEN_COUNT = 100000000 * (10**2);
/**
* Address of the owner of this smart contract.
*/
address public own... | /**
* CAER smart contract.
*/ | NatSpecMultiLine | freezeAccount | function freezeAccount(address _target, bool freeze) public {
require (msg.sender == owner);
require (msg.sender != _target);
frozenAccount[_target] = freeze;
emit FrozenFunds(_target, freeze);
| /**
* Freeze specific account
* May only be called by smart contract owner.
*/ | NatSpecMultiLine | v0.5.7+commit.6da8b019 | bzzr://b84abe2773709bf7c1c1df4f8edd46219153d7b3fa5cefa8256bd96c8f253c99 | {
"func_code_index": [
5630,
5855
]
} | 12,952 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://git... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c ... | /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
89,
483
]
} | 12,953 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://git... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | div | function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
567,
858
]
} | 12,954 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://git... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | sub | function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
972,
1094
]
} | 12,955 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://git... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
1158,
1293
]
} | 12,956 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @... | /**
* @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.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
217,
305
]
} | 12,957 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit 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.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
463,
795
]
} | 12,958 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256) {
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.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
1001,
1105
]
} | 12,959 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | BurnableToken | contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _w... | /**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/ | NatSpecMultiLine | burn | function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
| /**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
212,
290
]
} | 12,960 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | 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.
* https://github.com/ethereum/EIPs/issues/20
* 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(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_v... | /**
* @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.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
401,
893
]
} | 12,961 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | 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.
* https://github.com/ethereum/EIPs/issues/20
* 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;
emit 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
* race... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
1519,
1714
]
} | 12,962 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | 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.
* https://github.com/ethereum/EIPs/issues/20
* 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.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
2038,
2203
]
} | 12,963 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | 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.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit 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 _spender T... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
2663,
2973
]
} | 12,964 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | 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.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue... | /**
* @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 _spender T... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
3438,
3888
]
} | 12,965 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* a... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
813,
930
]
} | 12,966 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* a... | /**
* @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 {
_transferOwnership(_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.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
1095,
1203
]
} | 12,967 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* a... | /**
* @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) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
| /**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
1341,
1519
]
} | 12,968 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | Claimable | contract Claimable is Ownable {
address public pendingOwner;
/**
* @dev Modifier throws if called by any account other than the pendingOwner.
*/
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
/**
* @dev Allows the current owner to set the pendingOwner ad... | /**
* @title Claimable
* @dev Extension for the Ownable contract, where the ownership needs to be claimed.
* This allows the new owner to accept the transfer.
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
| /**
* @dev Allows the current owner to set the pendingOwner address.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
395,
496
]
} | 12,969 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | Claimable | contract Claimable is Ownable {
address public pendingOwner;
/**
* @dev Modifier throws if called by any account other than the pendingOwner.
*/
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
/**
* @dev Allows the current owner to set the pendingOwner ad... | /**
* @title Claimable
* @dev Extension for the Ownable contract, where the ownership needs to be claimed.
* This allows the new owner to accept the transfer.
*/ | NatSpecMultiLine | claimOwnership | function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
| /**
* @dev Allows the pendingOwner address to finalize the transfer.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
582,
753
]
} | 12,970 | |
TMNK | TMNK.sol | 0x4a3c0c2c39d23ce4dc4b5bde82d8de0f32d0a3b6 | Solidity | TMNK | contract TMNK is StandardToken, Claimable, BurnableToken {
using SafeMath for uint256;
string public constant name = "TMNK";
string public constant symbol = "TMNK";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 2800000 * (10 ** uint256(decimals));
/**
... | /**
* @title TMNK
*
* Symbol : TMNK
* Name : TMNK
* Total supply: 2800000.000000000000000000
* Decimals : 18
*
*/ | NatSpecMultiLine | transferAnyERC20Token | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Basic(tokenAddress).transfer(owner, tokens);
}
| /**
* @dev Owner can transfer out any accidentally sent ERC20 tokens
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://676592153ca91c3d3113c85978a73f36cfe02b06a48201110fb23115c8adb293 | {
"func_code_index": [
669,
854
]
} | 12,971 | |
OtcEscrow | contracts/token/OtcEscrow.sol | 0x2e45e774334d974beccab9ff6e21a1ecea82e9a3 | Solidity | OtcEscrow | contract OtcEscrow {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/* ========== Events =========== */
event VestingDeployed(address vesting);
/* ====== Modifiers ======== */
/**
* Throws if the sender is not Index Gov
*/
modifier onlyIndexGov() {
require... | /**
* @title OtcEscrow
* @author Badger DAO (Modified by Set Protocol)
*
* A simple OTC swap contract allowing two users to set the parameters of an OTC
* deal in the constructor arguments, and deposits the sold tokens into a vesting
* contract when a swap is completed.
*/ | NatSpecMultiLine | swap | function swap() external onlyOnce {
require(IERC20(index).balanceOf(address(this)) >= indexAmount, "insufficient INDEX");
// Transfer expected USDC from beneficiary
IERC20(usdc).safeTransferFrom(beneficiary, address(this), usdcAmount);
// Create Vesting contract
Vesting vesting = new Vesting(inde... | /**
* Executes the OTC deal. Sends the USDC from the beneficiary to Index Governance, and
* locks the INDEX in the vesting contract. Can only be called once.
*/ | NatSpecMultiLine | v0.6.10+commit.00c0fcaf | {
"func_code_index": [
2413,
3098
]
} | 12,972 | ||
OtcEscrow | contracts/token/OtcEscrow.sol | 0x2e45e774334d974beccab9ff6e21a1ecea82e9a3 | Solidity | OtcEscrow | contract OtcEscrow {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/* ========== Events =========== */
event VestingDeployed(address vesting);
/* ====== Modifiers ======== */
/**
* Throws if the sender is not Index Gov
*/
modifier onlyIndexGov() {
require... | /**
* @title OtcEscrow
* @author Badger DAO (Modified by Set Protocol)
*
* A simple OTC swap contract allowing two users to set the parameters of an OTC
* deal in the constructor arguments, and deposits the sold tokens into a vesting
* contract when a swap is completed.
*/ | NatSpecMultiLine | revoke | function revoke() external onlyIndexGov {
uint256 indexBalance = IERC20(index).balanceOf(address(this));
IERC20(index).safeTransfer(indexGov, indexBalance);
}
| /**
* Return INDEX to Index Governance to revoke the deal
*/ | NatSpecMultiLine | v0.6.10+commit.00c0fcaf | {
"func_code_index": [
3175,
3357
]
} | 12,973 | ||
OtcEscrow | contracts/token/OtcEscrow.sol | 0x2e45e774334d974beccab9ff6e21a1ecea82e9a3 | Solidity | OtcEscrow | contract OtcEscrow {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/* ========== Events =========== */
event VestingDeployed(address vesting);
/* ====== Modifiers ======== */
/**
* Throws if the sender is not Index Gov
*/
modifier onlyIndexGov() {
require... | /**
* @title OtcEscrow
* @author Badger DAO (Modified by Set Protocol)
*
* A simple OTC swap contract allowing two users to set the parameters of an OTC
* deal in the constructor arguments, and deposits the sold tokens into a vesting
* contract when a swap is completed.
*/ | NatSpecMultiLine | recoverUsdc | function recoverUsdc() external {
uint256 usdcBalance = IERC20(usdc).balanceOf(address(this));
IERC20(usdc).safeTransfer(beneficiary, usdcBalance);
}
| /**
* Recovers USDC accidentally sent to the contract
*/ | NatSpecMultiLine | v0.6.10+commit.00c0fcaf | {
"func_code_index": [
3430,
3603
]
} | 12,974 | ||
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @retu... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @return the name of the token.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
356,
444
]
} | 12,975 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @retu... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @return the symbol of the token.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
506,
598
]
} | 12,976 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @retu... | /**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/ | NatSpecMultiLine | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @return the number of decimals of the token.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
672,
760
]
} | 12,977 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
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.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | 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-solidity/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
106,
544
]
} | 12,978 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
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.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
674,
982
]
} | 12,979 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
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.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| /**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1115,
1270
]
} | 12,980 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
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.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| /**
* @dev Adds two unsigned integers, reverts on overflow.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1353,
1508
]
} | 12,981 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
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.
... | /**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| /**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1664,
1793
]
} | 12,982 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| /**
* @dev Total number of tokens in existence
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
297,
393
]
} | 12,983 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | balanceOf | function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return A uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
607,
718
]
} | 12,984 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | 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.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1052,
1188
]
} | 12,985 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | transfer | function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
| /**
* @dev Transfer token to a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
1357,
1502
]
} | 12,986 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | approve | function approve(address spender, uint256 value) public returns (bool) {
_approve(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
* race... | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
2144,
2297
]
} | 12,987 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | transferFrom | function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
| /**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address... | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
2765,
2998
]
} | 12,988 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when _allowed[msg.sender][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
* Emits... | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
3519,
3727
]
} | 12,989 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
| /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when _allowed[msg.sender][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
* Emits... | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
4253,
4471
]
} | 12,990 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| /**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
4693,
4960
]
} | 12,991 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | _mint | function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| /**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
5307,
5581
]
} | 12,992 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | _burn | function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
| /**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
5810,
6084
]
} | 12,993 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | _approve | function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
| /**
* @dev Approve an address to spend another addresses' tokens.
* @param owner The address that owns the tokens.
* @param spender The address that will spend the tokens.
* @param value The number of tokens that can be spent.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
6352,
6611
]
} | 12,994 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSuppl... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://eips.ethereum.org/EIPS/eip-20
* Originally based on code by FirstBlood:
* https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*
* This implementation emits additional Approva... | NatSpecMultiLine | _burnFrom | function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
| /**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* Emits an Approval event (reflecting the reduced allowance).
* @param account The account whose tokens will be burnt.
* @param valu... | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
7005,
7192
]
} | 12,995 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an account access to this role
*/
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.beare... | /**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/ | NatSpecMultiLine | add | function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
| /**
* @dev give an account access to this role
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
155,
346
]
} | 12,996 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an account access to this role
*/
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.beare... | /**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/ | NatSpecMultiLine | remove | function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
| /**
* @dev remove an account's access to this role
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
420,
614
]
} | 12,997 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an account access to this role
*/
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.beare... | /**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/ | NatSpecMultiLine | has | function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
| /**
* @dev check if an account has this role
* @return bool
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
703,
873
]
} | 12,998 | |
PrzToken | PrzToken.sol | 0x1acca663cf7e865eed61caeedc36dc0f7ab05baa | Solidity | ERC20Mintable | contract ERC20Mintable is ERC20, MinterRole {
/**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param value The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address ... | /**
* @title ERC20Mintable
* @dev ERC20 minting logic
*/ | NatSpecMultiLine | mint | function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
| /**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param value The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | bzzr://5d78c379a6bf749e648e225620a35e0a77cfd34d24e7b678a68f8c19d3733e8c | {
"func_code_index": [
294,
430
]
} | 12,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.