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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | approve | function approve(address to, uint256 tokenId) external;
| /**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token... | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
2894,
2954
]
} | 23,100 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | getApproved | function getApproved(uint256 tokenId) external view returns (address operator);
| /**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
3108,
3192
]
} | 23,101 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | setApprovalForAll | function setApprovalForAll(address operator, bool _approved) external;
| /**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
3519,
3594
]
} | 23,102 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | isApprovedForAll | function isApprovedForAll(address owner, address operator) external view returns (bool);
| /**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
3745,
3838
]
} | 23,103 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
| /**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {appro... | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
4427,
4531
]
} | 23,104 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721Enumerable | interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {bala... | /**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the total amount of tokens stored by the contract.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
134,
194
]
} | 23,105 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721Enumerable | interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {bala... | /**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
| /**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
377,
481
]
} | 23,106 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721Enumerable | interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {bala... | /**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 index) external view returns (uint256);
| /**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
657,
731
]
} | 23,107 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @d... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | name | function name() external view returns (string memory);
| /**
* @dev Returns the token collection name.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
108,
167
]
} | 23,108 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @d... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | symbol | function symbol() external view returns (string memory);
| /**
* @dev Returns the token collection symbol.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
238,
299
]
} | 23,109 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @d... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenURI | function tokenURI(uint256 tokenId) external view returns (string memory);
| /**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
400,
478
]
} | 23,110 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length();
}
| /**
* @dev See {IERC721-balanceOf}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
3515,
3741
]
} | 23,111 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | ownerOf | function ownerOf(uint256 tokenId) public view virtual override returns (address) {
return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
}
| /**
* @dev See {IERC721-ownerOf}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
3798,
3980
]
} | 23,112 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | name | function name() public view virtual override returns (string memory) {
return _name;
}
| /**
* @dev See {IERC721Metadata-name}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
4042,
4147
]
} | 23,113 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | symbol | function symbol() public view virtual override returns (string memory) {
return _symbol;
}
| /**
* @dev See {IERC721Metadata-symbol}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
4211,
4320
]
} | 23,114 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenURI | function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = baseURI();
// If there is no base URI, return the token URI.... | /**
* @dev See {IERC721Metadata-tokenURI}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
4386,
5183
]
} | 23,115 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | baseURI | function baseURI() public view virtual 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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
5417,
5519
]
} | 23,116 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
return _holderTokens[owner].at(index);
}
| /**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
5598,
5765
]
} | 23,117 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view virtual override returns (uint256) {
// _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
return _tokenOwners.length();
}
| /**
* @dev See {IERC721Enumerable-totalSupply}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
5836,
6052
]
} | 23,118 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
(uint256 tokenId, ) = _tokenOwners.at(index);
return tokenId;
}
| /**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
6124,
6301
]
} | 23,119 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | approve | function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor ap... | /**
* @dev See {IERC721-approve}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
6358,
6767
]
} | 23,120 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | getApproved | function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
| /**
* @dev See {IERC721-getApproved}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
6828,
7054
]
} | 23,121 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | setApprovalForAll | function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
| /**
* @dev See {IERC721-setApprovalForAll}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
7121,
7421
]
} | 23,122 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | isApprovedForAll | function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
| /**
* @dev See {IERC721-isApprovedForAll}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
7487,
7656
]
} | 23,123 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address from, address to, uint256 tokenId) public 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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
7718,
8028
]
} | 23,124 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
| /**
* @dev See {IERC721-safeTransferFrom}.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
8094,
8250
]
} | 23,125 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | 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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
8316,
8606
]
} | 23,126 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _safeTransfer | function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
9483,
9760
]
} | 23,127 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _exists | function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _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`),
* and stop existing when they are burned (`_burn`).
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
10068,
10200
]
} | 23,128 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _isApprovedOrOwner | function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(o... | /**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
10362,
10722
]
} | 23,129 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _safeMint | function _safeMint(address to, uint256 tokenId) internal virtual {
_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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
11060,
11175
]
} | 23,130 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _safeMint | function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
11397,
11652
]
} | 23,131 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _mint | function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
11983,
12392
]
} | 23,132 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _burn | function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId); // internal owner
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
... | /**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
12616,
13166
]
} | 23,133 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, 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`.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
13498,
14102
]
} | 23,134 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _setTokenURI | function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
| /**
* @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
14253,
14473
]
} | 23,135 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _setBaseURI | function _setBaseURI(string memory baseURI_) internal virtual {
_baseURI = baseURI_;
}
| /**
* @dev Internal function to set the base URI for all token IDs. It is
* automatically added as a prefix to the value returned in {tokenURI},
* or to the token ID if {tokenURI} is empty.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
14698,
14803
]
} | 23,136 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | 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,
... | /**
* @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.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
15363,
15972
]
} | 23,137 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _approve | function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner
}
| /**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/ | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
16086,
16283
]
} | 23,138 |
SingleStaking | SingleStaking.sol | 0xa82caec7b2ce9ae5c50eabf795e524b3a4ca09b4 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
| /**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``... | NatSpecMultiLine | v0.7.3+commit.9bfce1f6 | None | ipfs://3d7eda5090e51e9086e111efdbe3ad62f875b5246c3bfe4611a85d9110a53b3a | {
"func_code_index": [
16891,
16989
]
} | 23,139 |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Pausable | contract Pausable is Ownable {
bool public stopped;
modifier stopInEmergency {
if (stopped) {
revert();
}
_;
}
modifier onlyInEmergency {
if (!stopped) {
revert();
}
_;
}
// Called by the owner in emergen... | emergencyStop | function emergencyStop() external onlyOwner {
stopped = true;
}
| // Called by the owner in emergency, triggers stopped state | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
348,
430
]
} | 23,140 | |||
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Pausable | contract Pausable is Ownable {
bool public stopped;
modifier stopInEmergency {
if (stopped) {
revert();
}
_;
}
modifier onlyInEmergency {
if (!stopped) {
revert();
}
_;
}
// Called by the owner in emergen... | release | function release() external onlyOwner onlyInEmergency {
stopped = false;
}
| // Called by the owner to end of emergency, returns to normal state | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
506,
599
]
} | 23,141 | |||
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | PullPayment | contract PullPayment {
mapping(address => uint) public payments;
event RefundETH(address to, uint value);
// Store sent amount as credit to be pulled, called by payer
function asyncSend(address dest, uint amount) internal {
payments[dest] += amount;
}
// Withdraw accumul... | // Base contract supporting async send for pull payments.
// Inherit from this contract and use asyncSend instead of send. | LineComment | asyncSend | function asyncSend(address dest, uint amount) internal {
payments[dest] += amount;
}
| // Store sent amount as credit to be pulled, called by payer | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
187,
290
]
} | 23,142 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | PullPayment | contract PullPayment {
mapping(address => uint) public payments;
event RefundETH(address to, uint value);
// Store sent amount as credit to be pulled, called by payer
function asyncSend(address dest, uint amount) internal {
payments[dest] += amount;
}
// Withdraw accumul... | // Base contract supporting async send for pull payments.
// Inherit from this contract and use asyncSend instead of send. | LineComment | withdrawPayments | function withdrawPayments() internal returns (bool) {
address payee = msg.sender;
uint payment = payments[payee];
if (payment == 0) {
revert();
}
if (this.balance < payment) {
revert();
}
payments[payee] = 0;
if (!payee.send(payment)) {
revert()... | // Withdraw accumulated balance, called by payee | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
351,
797
]
} | 23,143 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | Crowdsale | function Crowdsale() {
multisigETH = 0x62739Ec09cdD8FAe2f7b976f8C11DbE338DF8750;
team = 0x62739Ec09cdD8FAe2f7b976f8C11DbE338DF8750;
GXCSentToETH = 487000 * multiplier;
minInvestETH = 100000000000000000 ; // 0.1 eth
startBlock = 0; // ICO start block
... | // Crowdsale {constructor}
// @notice fired when contract is crated. Initilizes all constnat variables. | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
1767,
2371
]
} | 23,144 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | updateTokenAddress | function updateTokenAddress(GXC _GXCAddress) public onlyOwner() returns(bool res) {
gxc = _GXCAddress;
return true;
}
| // @notice Specify address of token contract
// @param _GXCAddress {address} address of GXC token contrac
// @return res {bool} | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
2517,
2668
]
} | 23,145 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | updateTeamAddress | function updateTeamAddress(address _teamAddress) public onlyOwner returns(bool){
team = _teamAddress;
return true;
}
| // @notice modify this address should this be needed. | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
2731,
2876
]
} | 23,146 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | numberOfBackers | function numberOfBackers()constant returns (uint){
return backersIndex.length;
}
| // @notice return number of contributors
// @return {uint} number of contributors | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
2972,
3071
]
} | 23,147 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | function () payable {
handleETH(msg.sender);
}
| // {fallback function}
// @notice It will call internal function which handels allocation of Ether and calculates GXC tokens. | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
3210,
3284
]
} | 23,148 | ||
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | start | function start(uint _block) onlyOwner() {
startBlock = block.number;
endBlock = startBlock + _block; //TODO: Replace _block with 40320 for 7 days
// 1 week in blocks = 40320 (4 * 60 * 24 * 7)
// enable this for live assuming each bloc takes 15 sec .
crowdsaleClosed = false;
}
| // @notice It will be called by owner to start the sale | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
3351,
3682
]
} | 23,149 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | handleETH | function handleETH(address _backer) internal stopInEmergency respectTimeFrame returns(bool res) {
if (msg.value < minInvestETH) revert(); // stop when required minimum is not sent
uint GXCToSend = (msg.value * multiplier)/ tokenPriceWei ; // calculate number of tokens
// Ensure that max cap hasn't ... | // @notice It will be called by fallback function whenever ether is sent to it
// @param _backer {address} address of beneficiary
// @return res {bool} true if transaction was successful | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
3888,
4904
]
} | 23,150 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | finalize | function finalize() onlyOwner() {
if (crowdsaleClosed) revert();
uint daysToRefund = 4*60*24*10; //10 days
if (block.number < endBlock && GXCSentToETH < maxCap -100 ) revert(); // -100 is used to allow closing of the campaing when contribution is near
... | // @notice This function will finalize the sale.
// It will only execute if predetermined sale time passed or all tokens are sold. | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
5050,
6367
]
} | 23,151 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | drain | function drain() onlyOwner(){
if (!owner.send(this.balance)) revert();
}
| // @notice Failsafe drain | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
6410,
6501
]
} | 23,152 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | transferDevTokens | function transferDevTokens(address _devAddress) onlyOwner returns(bool){
if (!gxc.transfer(_devAddress, gxc.balanceOf(this)))
revert();
return true;
}
| // @notice Failsafe transfer tokens for the team to given account | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
6576,
6776
]
} | 23,153 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | prepareRefund | function prepareRefund() minCapNotReached internal returns (bool){
uint value = backers[msg.sender].GXCSent;
if (value == 0) revert();
if (!gxc.burn(msg.sender, value)) revert();
uint ETHToSend = backers[msg.sender].weiReceived;
backers[msg.sender].weiReceived = 0;
backers[ms... | // @notice Prepare refund of the backer if minimum is not reached
// burn the tokens | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
6876,
7409
]
} | 23,154 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | Crowdsale | contract Crowdsale is SafeMath, Pausable, PullPayment {
struct Backer {
uint weiReceived; // amount of ETH contributed
uint GXCSent; // amount of tokens sent
}
GXC public gxc; // DMINI contract reference
address public multisigETH; // Multisig contract that will rec... | // Crowdsale Smart Contract
// This smart contract collects ETH and in return sends GXC tokens to the Backers | LineComment | refund | function refund() public returns (bool){
if (!prepareRefund()) revert();
if (!withdrawPayments()) revert();
return true;
}
| // @notice refund the backer | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
7446,
7609
]
} | 23,155 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | GXC | contract GXC is ERC20, SafeMath, Ownable {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals; // How many decimals to show.
string public version = 'v0.1';
uint public initialSupply;
uint public totalSupply;
bool public locked;
... | // The GXC token | LineComment | GXC | function GXC(address _crowdSaleAddress) {
locked = true; // Lock the transfer of tokens during the crowdsale
initialSupply = 10000000 * multiplier;
totalSupply = initialSupply;
name = 'GXC'; // Set the name for display purposes
symbol = 'GXC'; // Set the symbol for display purposes
... | // The GXC Token constructor | LineComment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
892,
1427
]
} | 23,156 | |
Crowdsale | Crowdsale.sol | 0x66345ae2b6fc2ce02684eee1aa1453257f77e635 | Solidity | GXC | contract GXC is ERC20, SafeMath, Ownable {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals; // How many decimals to show.
string public version = 'v0.1';
uint public initialSupply;
uint public totalSupply;
bool public locked;
... | // The GXC token | LineComment | transferFrom | function transferFrom(address _from, address _to, uint256 _value) onlyUnlocked returns(bool success) {
if (balances[_from] < _value) revert(); // Check if the sender has enough
if (_value > allowed[_from][msg.sender]) revert(); // Check allowance
balances[_from] = safeSub(balances[_from], _value); // Sub... | /* A contract attempts to get the coins */ | Comment | v0.4.13+commit.fb4cb1a | bzzr://cd8c01664a70684917b5a770e9f50f5e2fd94c438366fa540c8a550fe48a8f8e | {
"func_code_index": [
2337,
2936
]
} | 23,157 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | SafeMath | library SafeMath {
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds... | /**
* @title SafeMath
* @dev 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 numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
138,
293
]
} | 23,158 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | SafeMath | library SafeMath {
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds... | /**
* @title SafeMath
* @dev 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 numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
364,
519
]
} | 23,159 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | Ownable | contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @return the address of the owner.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
206,
290
]
} | 23,160 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | Ownable | contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws... | /**
* @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 OwnershipTransferred(_owner, address(0));
_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.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
745,
890
]
} | 23,161 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | Ownable | contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
1062,
1261
]
} | 23,162 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| /**
* @dev Total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
316,
412
]
} | 23,163 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | 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 An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
623,
734
]
} | 23,164 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | 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.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
1068,
1204
]
} | 23,165 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | NatSpecMultiLine | transfer | function transfer(address to, uint256 value) public returns (bool) {
_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.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
1370,
1515
]
} | 23,166 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | NatSpecMultiLine | approve | function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
| /**
* @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.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
2157,
2406
]
} | 23,167 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | NatSpecMultiLine | transferFrom | function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, 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.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
2874,
3108
]
} | 23,168 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_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
* Emits an Approva... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
3618,
3946
]
} | 23,169 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| /**
* @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
* Emits an Approva... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
4461,
4799
]
} | 23,170 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | 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.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
5016,
5283
]
} | 23,171 | |
FansGoGo | FansGoGo.sol | 0xfdac63e4aed8ab64ee6a58b4985363f703e1bdc8 | Solidity | ExtensionToken | contract ExtensionToken is IEIPERC20,Ownable {
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
*/
... | /**
* @title ExtensionToken token
*
* This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
* all accounts just by listening to said events. Note that this isn't required by the specification, and other
* compliant implementations may not do it.
... | 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.4.24+commit.e67f0147 | bzzr://2568f5e764f79eec53fa32860e801b3e6ef6ca429c15134c77cb52d8882f8de3 | {
"func_code_index": [
5630,
5904
]
} | 23,172 | |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | name | function name() public view virtual override returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
890,
995
]
} | 23,173 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | symbol | function symbol() public view virtual override returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
1109,
1218
]
} | 23,174 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decimals | function decimals() public view virtual override returns (uint8) {
return 18;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
1852,
1950
]
} | 23,175 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | totalSupply | function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
2010,
2123
]
} | 23,176 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
2181,
2313
]
} | 23,177 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
require(tokenLocked == false, 'token locked' );
require( RestrictedAddress[msg.sender] != true, 'msg.sender restricted from transfers');
_transfer(_msgSender(), recipient, amount);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
2551,
2891
]
} | 23,178 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
2949,
3105
]
} | 23,179 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
3247,
3421
]
} | 23,180 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
require(tokenLocked == false, 'token locked');
require( RestrictedAddress[msg.sender] != true, 'msg.sender restricted from transfers');
_transfer(sender, recipient, amount);
ui... | /**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
3898,
4487
]
} | 23,181 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
4891,
5111
]
} | 23,182 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - sub... | /**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
5609,
5991
]
} | 23,183 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 sende... | /**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
*... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
6476,
7085
]
} | 23,184 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _mint | function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
| /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
7367,
7710
]
} | 23,185 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _burn | function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds ba... | /**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
8038,
8537
]
} | 23,186 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _approve | function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amoun... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero a... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
8970,
9321
]
} | 23,187 |
GoldAppleToken | ERC20-v0.8.0.sol | 0x9046521e82c0431164a502c43b8cd6d7e72c24c2 | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bool public tokenLocked = false;
... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
| /**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* -... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://5996bc004602a6ace282cb95f4acf39d57319bb356a733a77669262665919e8c | {
"func_code_index": [
9919,
10016
]
} | 23,188 |
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | totalSupply | function totalSupply() constant returns (uint256 supply) {}
| /// @return total amount of tokens | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
60,
124
]
} | 23,189 | |||
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | balanceOf | function balanceOf(address _owner) constant returns (uint256 balance) {}
| /// @param _owner The address from which the balance will be retrieved
/// @return The balance | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
232,
309
]
} | 23,190 | |||
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transfer | function transfer(address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
546,
623
]
} | 23,191 | |||
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
946,
1042
]
} | 23,192 | |||
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | approve | function approve(address _spender, uint256 _value) returns (bool success) {}
| /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
1326,
1407
]
} | 23,193 | |||
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | allowance | function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
| /// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
1615,
1712
]
} | 23,194 | |||
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | BitcoinCrown | contract BitcoinCrown is StandardToken {
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces... | BitcoinCrown | function BitcoinCrown() {
balances[msg.sender] = 70000000000000000000000000; // Give the creator all initial tokens.
totalSupply = 70000000000000000000000000; // Update total supply
name = "BitcoinCrown"; // Set the name for dis... | // Where should the raised ETH go?
// This is a constructor function
// which means the following function name has to match the contract name declared above | LineComment | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
1159,
1960
]
} | 23,195 | |||
BitcoinCrown | BitcoinCrown.sol | 0xc0c05862cca68b0b4c806796a6e7d965a6f18095 | Solidity | BitcoinCrown | contract BitcoinCrown is StandardToken {
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces... | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually s... | /* Approves and then calls the receiving contract */ | Comment | v0.4.21+commit.dfe3193c | bzzr://7e4b20c9c30849ece9f62e286df2c266af97418b4f0879c989136e6d6d2f9cf4 | {
"func_code_index": [
2556,
3361
]
} | 23,196 | |||
EnvoyChain_proxy | EnvoyChain_proxy.sol | 0x947e7997501cc0c6d775d0c33dac2d03bc7986b6 | Solidity | EnvoyChain_v1 | contract EnvoyChain_v1 is owned {
/*===============================
= DATA STORAGE =
===============================*/
// Public variables of the token
using SafeMath for uint256;
string public name;
string public symbol;
uint256 public decimals;
u... | //****************************************************************************//
//--------------------- MAIN CODE STARTS HERE ---------------------//
//****************************************************************************// | LineComment | _transfer | function _transfer(address _from, address _to, uint _value) internal {
//checking conditions
require(!safeguard);
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(!frozenAccount[_from]); // Check if sender ... | /* Internal transfer, only can be called by this contract */ | Comment | v0.5.5+commit.47a71e8f | bzzr://0b8814a70f70cd24183ed1aa1d3cee090ef12a9febc912286ce9e8c334b5e808 | {
"func_code_index": [
1389,
2180
]
} | 23,197 | |
EnvoyChain_proxy | EnvoyChain_proxy.sol | 0x947e7997501cc0c6d775d0c33dac2d03bc7986b6 | Solidity | EnvoyChain_v1 | contract EnvoyChain_v1 is owned {
/*===============================
= DATA STORAGE =
===============================*/
// Public variables of the token
using SafeMath for uint256;
string public name;
string public symbol;
uint256 public decimals;
u... | //****************************************************************************//
//--------------------- MAIN CODE STARTS HERE ---------------------//
//****************************************************************************// | LineComment | transfer | function transfer(address _to, uint256 _value) public returns (bool success) {
//no need to check for input validations, as that is ruled by SafeMath
_transfer(msg.sender, _to, _value);
return true;
}
| /**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.5.5+commit.47a71e8f | bzzr://0b8814a70f70cd24183ed1aa1d3cee090ef12a9febc912286ce9e8c334b5e808 | {
"func_code_index": [
2407,
2644
]
} | 23,198 | |
EnvoyChain_proxy | EnvoyChain_proxy.sol | 0x947e7997501cc0c6d775d0c33dac2d03bc7986b6 | Solidity | EnvoyChain_v1 | contract EnvoyChain_v1 is owned {
/*===============================
= DATA STORAGE =
===============================*/
// Public variables of the token
using SafeMath for uint256;
string public name;
string public symbol;
uint256 public decimals;
u... | //****************************************************************************//
//--------------------- MAIN CODE STARTS HERE ---------------------//
//****************************************************************************// | LineComment | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
| /**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.5.5+commit.47a71e8f | bzzr://0b8814a70f70cd24183ed1aa1d3cee090ef12a9febc912286ce9e8c334b5e808 | {
"func_code_index": [
2943,
3277
]
} | 23,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.