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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | isApprovedForAll | function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
return _operatorApprovals[owner][operator];
}
| /**
* @dev See {IERC721-isApprovedForAll}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
3635,
3854
]
} | 29,600 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | 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, ... | /**
* @dev See {IERC721-transferFrom}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
3916,
4297
]
} | 29,601 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | safeTransferFrom | function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
| /**
* @dev See {IERC721-safeTransferFrom}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
4363,
4553
]
} | 29,602 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | 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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
4619,
4989
]
} | 29,603 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
5866,
6223
]
} | 29,604 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _exists | function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _owners.length && _owners[tokenId] != address(0);
}
| /**
* @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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
6531,
6691
]
} | 29,605 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _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 ||
getAp... | /**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
6853,
7310
]
} | 29,606 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _safeMint | function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
| /**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
7647,
7762
]
} | 29,607 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
7984,
8310
]
} | 29,608 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _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);
_owners.push(to);
emit Transfer(address(0), to, tokenId);
... | /**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
8641,
8992
]
} | 29,609 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _burn | function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_owners[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
| /**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
9216,
9553
]
} | 29,610 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _transfer | function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(
ERC721.ownerOf(tokenId) == from,
"ERC721: transfer of token that is not own"
);
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from... | /**
* @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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
9885,
10443
]
} | 29,611 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _approve | function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
| /**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
10556,
10735
]
} | 29,612 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _checkOnERC721Received | function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try
IERC721Receiver(to).onERC721Received(
_msgSender(),
from,
tokenId,
... | /**
* @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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
11295,
12280
]
} | 29,613 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721 | abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) priva... | _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.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
12847,
12978
]
} | 29,614 | ||
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721Enumerable | abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super... | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/ | NatSpecMultiLine | supportsInterface | function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
| /**
* @dev See {IERC165-supportsInterface}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
131,
360
]
} | 29,615 |
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721Enumerable | abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super... | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view virtual override returns (uint256) {
return _owners.length;
}
| /**
* @dev See {IERC721Enumerable-totalSupply}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
431,
546
]
} | 29,616 |
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721Enumerable | abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super... | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/ | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < _owners.length, "ERC721Enumerable: global index out of bounds");
return index;
}
| /**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
618,
828
]
} | 29,617 |
NonFungibleSmilebyTrippie2022 | ERC2000000.sol | 0xf61510d3ff3fdecf18663824cd12f4ab43c3bd03 | Solidity | ERC721Enumerable | abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super... | /**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/ | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
uint count;
for(uint i; i < _owners.length; i++){
if(owner == _owners[i]){
if(count... | /**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://29dedbf78761364959ffa20dea64484f6930b1cedaa8c5190c7dc1b4ae95ce5a | {
"func_code_index": [
907,
1402
]
} | 29,618 |
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | TokenERC20 | function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
nam... | /**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
778,
1323
]
} | 29,619 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | _transfer | function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to])... | /**
* Internal transfer, only can be called by this contract
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
1407,
2249
]
} | 29,620 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | transfer | function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
| /**
* 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.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
2455,
2567
]
} | 29,621 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | 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] -= _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.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
2842,
3143
]
} | 29,622 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | approve | function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| /**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
3407,
3583
]
} | 29,623 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
| /**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to s... | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
3977,
4329
]
} | 29,624 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | burn | function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _val... | /**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
4499,
4873
]
} | 29,625 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | TokenERC20 | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 9;
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (a... | burnFrom | function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Sub... | /**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
5131,
5742
]
} | 29,626 | |||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | PoliticoinToken | function PoliticoinToken( ) TokenERC20(31000000000, 'Politicoin', 'PBLC') public {}
| /* Initializes contract with initial supply tokens to the creator of the contract */ | Comment | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
414,
502
]
} | 29,627 | |
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | _transfer | function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanc... | /* Internal transfer, only can be called by this contract */ | Comment | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
571,
1353
]
} | 29,628 | |
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | mintToken | function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
| /// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
1545,
1803
]
} | 29,629 | |
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | freezeAccount | function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
| /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
1984,
2145
]
} | 29,630 | |
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | setPrices | function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
| /// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
2388,
2548
]
} | 29,631 | |
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | function () payable public {
buy();
}
| /// Default fallback function to buy tokens | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
2600,
2656
]
} | 29,632 | ||
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | buy | function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
| /// @notice Buy tokens from contract by sending ether | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
2718,
2927
]
} | 29,633 | |
PoliticoinToken | PoliticoinToken.sol | 0xd810650bd094a2eba59912ecfc07ee108699116c | Solidity | PoliticoinToken | contract PoliticoinToken is owned, TokenERC20 {
uint256 public sellPrice = 63770;
uint256 public buyPrice = 63800;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);... | /******************************************/ | NatSpecMultiLine | sell | function sell(uint256 amount) public {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's importan... | /// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://ab22d3a0d7906f4f6f59da28fb39906b04b0f1cce4a2deef7f375340ff39724c | {
"func_code_index": [
3031,
3419
]
} | 29,634 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a... | /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
87,
474
]
} | 29,635 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
558,
838
]
} | 29,636 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
952,
1068
]
} | 29,637 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
1132,
1262
]
} | 29,638 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev Transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev Total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
199,
287
]
} | 29,639 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev Transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| /**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
445,
777
]
} | 29,640 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev Transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
983,
1087
]
} | 29,641 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_v... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
399,
889
]
} | 29,642 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
1515,
1710
]
} | 29,643 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
2034,
2199
]
} | 29,644 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender T... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
2659,
2969
]
} | 29,645 | |
RDA | RDA.sol | 0x44866d13944132100d56f63562b8afab890251da | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue)... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender T... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://7e641f7c7676b9f95bef5e8dc9c3a498d0b96bce682416833cd8ee5d67afdc70 | {
"func_code_index": [
3434,
3883
]
} | 29,646 | |
StakeDaoNFTPalace | StakedaoNFTPalace.sol | 0x221738f73fa4bfca91918e77d112b87d918c751f | Solidity | StakeDaoNFTPalace | contract StakeDaoNFTPalace is StakeTokenWrapper, Ownable {
ERC1155Tradable public nft;
mapping(address => uint256) public lastUpdateTime;
mapping(address => uint256) public points;
mapping(uint256 => uint256) public cards;
event CardAdded(uint256 card, uint256 points);
event Staked(address ind... | stake | function stake(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Invalid amount");
super.stake(amount);
emit Staked(msg.sender, amount);
}
| // stake visibility is public as overriding StakeTokenWrapper's stake() function | LineComment | v0.5.17+commit.d19bba13 | Unlicense | {
"func_code_index": [
1658,
1850
]
} | 29,647 | |||
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | RocketToken | function RocketToken() public {
symbol = "RKT";
name = "Rocket Token";
decimals = 8;
_totalSupply = 100000000000;
balances[0xeAE55239EF5Bb78E41EEeDa62ab2D6c7f4da6706] = _totalSupply;
emit Transfer(address(0),0xeAE55239EF5Bb78E41EEeDa62ab2D6c7f4da6706 , _totalSupply);
}
| // ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
458,
791
]
} | 29,648 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | totalSupply | function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
| // ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
979,
1100
]
} | 29,649 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | balanceOf | function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
| // ------------------------------------------------------------------------
// Get the token balance for account tokenOwner
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
1320,
1449
]
} | 29,650 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | transfer | function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Transfer the balance from token owner's account to to account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
1793,
2075
]
} | 29,651 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | approve | function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double... | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
2583,
2796
]
} | 29,652 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | transferFrom | function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
r... | // ------------------------------------------------------------------------
// Transfer tokens from the from account to the to account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the from account and
// - From account must have sufficient balance to transfer
// - S... | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
3327,
3690
]
} | 29,653 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | allowance | function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
| // ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
3973,
4129
]
} | 29,654 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | approveAndCall | function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account. The spender contract function
// receiveApproval(...) is then executed
// --------------------------------------------------------------------... | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
4484,
4806
]
} | 29,655 |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | function () public payable {
revert();
}
| // ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
4998,
5057
]
} | 29,656 | |
RocketToken | RocketToken.sol | 0x6f122109a8ece4af04baf2453318693633bd1246 | Solidity | RocketToken | contract RocketToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | transferAnyERC20Token | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
| // ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://6ee3c2043531f9481abfbb490024130526dcd663e581f83ebd6622c1e663bf57 | {
"func_code_index": [
5290,
5479
]
} | 29,657 |
TailEReaper | Ownable.sol | 0x0c6ed4900cde08e67c109ca9e5d946a58c001fb9 | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* ... | NatSpecMultiLine | owner | function owner() public view virtual returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://c9ece1a769ddad8013046e91372363af72e6eba5e8dc7aaf3468b398f80090bb | {
"func_code_index": [
393,
482
]
} | 29,658 |
TailEReaper | Ownable.sol | 0x0c6ed4900cde08e67c109ca9e5d946a58c001fb9 | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* ... | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://c9ece1a769ddad8013046e91372363af72e6eba5e8dc7aaf3468b398f80090bb | {
"func_code_index": [
1025,
1130
]
} | 29,659 |
TailEReaper | Ownable.sol | 0x0c6ed4900cde08e67c109ca9e5d946a58c001fb9 | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* ... | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://c9ece1a769ddad8013046e91372363af72e6eba5e8dc7aaf3468b398f80090bb | {
"func_code_index": [
1275,
1477
]
} | 29,660 |
TailEReaper | Ownable.sol | 0x0c6ed4900cde08e67c109ca9e5d946a58c001fb9 | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* ... | NatSpecMultiLine | _transferOwnership | function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://c9ece1a769ddad8013046e91372363af72e6eba5e8dc7aaf3468b398f80090bb | {
"func_code_index": [
1627,
1818
]
} | 29,661 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
94,
154
]
} | 29,662 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
237,
310
]
} | 29,663 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
534,
616
]
} | 29,664 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
895,
983
]
} | 29,665 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
1647,
1726
]
} | 29,666 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
2039,
2141
]
} | 29,667 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
251,
437
]
} | 29,668 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
707,
848
]
} | 29,669 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
1138,
1335
]
} | 29,670 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
1581,
2057
]
} | 29,671 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
2520,
2657
]
} | 29,672 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
3140,
3423
]
} | 29,673 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
3875,
4010
]
} | 29,674 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
4482,
4653
]
} | 29,675 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
497,
581
]
} | 29,676 | ||
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
1139,
1292
]
} | 29,677 | ||
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
1442,
1691
]
} | 29,678 | ||
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
9252,
9340
]
} | 29,679 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
9454,
9546
]
} | 29,680 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
10179,
10267
]
} | 29,681 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | totalSupply | function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
10327,
10432
]
} | 29,682 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
10490,
10614
]
} | 29,683 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
10822,
11002
]
} | 29,684 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
11060,
11216
]
} | 29,685 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | 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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
11358,
11532
]
} | 29,686 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
| /**
* @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 `amou... | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
12001,
12327
]
} | 29,687 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
12731,
12954
]
} | 29,688 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
| /**
* @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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
13452,
13726
]
} | 29,689 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | NatSpecMultiLine | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(_freeze == false, "Contract is frozen.");
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
requir... | /**
* @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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
14211,
18412
]
} | 29,690 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | 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 = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfe... | /** @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
*
* - `to` cannot be the zero address.
*/ | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
18688,
19071
]
} | 29,691 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | 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);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _to... | /**
* @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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
19398,
19821
]
} | 29,692 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | 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 is 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... | NatSpecMultiLine | v0.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
20256,
20607
]
} | 29,693 |
PampToken | PampToken.sol | 0xce833222051740aa5427d089a46ff3918763107f | Solidity | PampToken | contract PampToken is Ownable, IERC20 {
using SafeMath for uint256;
struct staker {
uint startTimestamp;
uint lastTimestamp;
}
struct update {
uint timestamp;
uint numerator;
uint denominator;
uint price; // In USD. 0001 is $0... | /**
* @dev Implementation of the Pamp Network: https://pamp.network
* Pamp Network (PAMP) is the world's first price-reactive cryptocurrency.
* That is, the inflation rate of the token is wholly dependent on its market activity.
* Minting does not happen when the price is less than the day prior.
* When the p... | 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.6.0+commit.26b70077 | None | ipfs://83037fbb558767517f5f79bcba92f75a310b10e43e8baec6a030acfe18cc3e8c | {
"func_code_index": [
21478,
21575
]
} | 29,694 |
UniTradeMarketOrders | UniTradeMarketOrders.sol | 0x42dcbdf298b16394f94257bafc296fc909452cc6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | Unlicense | ipfs://8c475e1f184b9dfb77e3dc81e3dfa5930ac305b1d97e4341ccf595952d9ae6b4 | {
"func_code_index": [
259,
445
]
} | 29,695 |
UniTradeMarketOrders | UniTradeMarketOrders.sol | 0x42dcbdf298b16394f94257bafc296fc909452cc6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | Unlicense | ipfs://8c475e1f184b9dfb77e3dc81e3dfa5930ac305b1d97e4341ccf595952d9ae6b4 | {
"func_code_index": [
723,
864
]
} | 29,696 |
UniTradeMarketOrders | UniTradeMarketOrders.sol | 0x42dcbdf298b16394f94257bafc296fc909452cc6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | Unlicense | ipfs://8c475e1f184b9dfb77e3dc81e3dfa5930ac305b1d97e4341ccf595952d9ae6b4 | {
"func_code_index": [
1162,
1359
]
} | 29,697 |
UniTradeMarketOrders | UniTradeMarketOrders.sol | 0x42dcbdf298b16394f94257bafc296fc909452cc6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | Unlicense | ipfs://8c475e1f184b9dfb77e3dc81e3dfa5930ac305b1d97e4341ccf595952d9ae6b4 | {
"func_code_index": [
1613,
2089
]
} | 29,698 |
UniTradeMarketOrders | UniTradeMarketOrders.sol | 0x42dcbdf298b16394f94257bafc296fc909452cc6 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.6.12+commit.27d51765 | Unlicense | ipfs://8c475e1f184b9dfb77e3dc81e3dfa5930ac305b1d97e4341ccf595952d9ae6b4 | {
"func_code_index": [
2560,
2697
]
} | 29,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.