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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _safeTransfer | function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
| /**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is eq... | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
9483,
9760
]
} | 25,400 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _exists | function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _tokenOwners.contains(tokenId);
}
| /**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
10068,
10200
]
} | 25,401 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _isApprovedOrOwner | function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(o... | /**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
10362,
10722
]
} | 25,402 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _safeMint | function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
| /**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
d*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
11060,
11175
]
} | 25,403 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _safeMint | function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
| /**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
11397,
11652
]
} | 25,404 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _mint | function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId... | /**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
11983,
12392
]
} | 25,405 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _burn | function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId); // internal owner
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
... | /**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
12616,
13166
]
} | 25,406 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
//... | /**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
13498,
14102
]
} | 25,407 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _setTokenURI | function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
| /**
* @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
14253,
14473
]
} | 25,408 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _setBaseURI | function _setBaseURI(string memory baseURI_) internal virtual {
_baseURI = baseURI_;
}
| /**
* @dev Internal function to set the base URI for all token IDs. It is
* automatically added as a prefix to the value returned in {tokenURI},
* or to the token ID if {tokenURI} is empty.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
14698,
14803
]
} | 25,409 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _checkOnERC721Received | function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes memory returndata = to.functionCall(abi.encodeWithSelector(
IERC721Receiver(to).onERC721Received.selector,
... | /**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param to... | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
15363,
15972
]
} | 25,410 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
| /**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``... | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
16771,
16869
]
} | 25,411 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | BidFeswaPair | function BidFeswaPair(address tokenA, address tokenB, address to) external payable returns (uint256 tokenID) {
require(block.timestamp > SaleStartTime, 'FESN: BID NOT STARTED');
require(tokenA != tokenB, 'FESN: IDENTICAL_ADDRESSES');
require(msg.value >= PriceLowLimit, 'FESN: PAY LESS');
(address ... | /**
* @dev Bid for the token-pair swap pool with higher price.
* Create the new token for the fisrt-time calling with minumum initial price
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
2188,
5266
]
} | 25,412 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | FeswaPairSettle | function FeswaPairSettle(uint256 tokenID) external {
require(msg.sender == ownerOf(tokenID), 'FESN: NOT TOKEN OWNER'); // ownerOf checked if tokenID existing
FeswaPair storage pairInfo = ListPools[tokenID];
if(pairInfo.poolState == PoolRunningPhase.BidPhase){
require(block.times... | /**
* @dev Settle the bid for the swap pair.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
5335,
6251
]
} | 25,413 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | FeswaPairForSale | function FeswaPairForSale(uint256 tokenID, uint256 pairPrice) external returns (uint256 newPrice) {
require(msg.sender == ownerOf(tokenID), 'FESN: NOT TOKEN OWNER'); // ownerOf checked if tokenID existing
FeswaPair storage pairInfo = ListPools[tokenID];
require(pairInfo.poolState >= Pool... | /**
* @dev Sell the Pair with the specified Price.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
6326,
7074
]
} | 25,414 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | FeswaPairBuyIn | function FeswaPairBuyIn(uint256 tokenID, uint256 newPrice, address to) external payable returns (uint256 getPrice) {
require(_exists(tokenID), 'FESN: TOKEN NOT CREATED');
FeswaPair storage pairInfo = ListPools[tokenID];
require( pairInfo.poolState == PoolRunningPhase.PoolForSale, 'FESN: NOT FOR SALE');
... | /**
* @dev Sell the Pair with the specified Price.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
7149,
8271
]
} | 25,415 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | getPoolInfoByTokens | function getPoolInfoByTokens(address tokenA, address tokenB) external view returns (uint256 tokenID, address nftOwner, FeswaPair memory pairInfo) {
(address token0, address token1) = (tokenA < tokenB) ? (tokenA, tokenB) : (tokenB, tokenA);
tokenID = uint256(keccak256(abi.encodePacked(address(this), token0, to... | /**
* @dev Return the token-pair information
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
8340,
8742
]
} | 25,416 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | getPoolInfo | function getPoolInfo(uint256 tokenID) public view returns (address nftOwner, FeswaPair memory pairInfo) {
if(_exists(tokenID)){
nftOwner = ownerOf(tokenID);
pairInfo = ListPools[tokenID];
}
}
| /**
* @dev Return the token pair addresses by TokenID
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
8820,
9065
]
} | 25,417 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | setPriceLowLimit | function setPriceLowLimit(uint256 priceLowLimit) public onlyOwner{
PriceLowLimit = priceLowLimit;
}
| /**
* @dev Set the initial pool price
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
9126,
9244
]
} | 25,418 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | withdraw | function withdraw(address to, uint256 value) public onlyOwner{
require(address(this).balance >= value, 'FESN: INSUFFICIENT BALANCE');
TransferHelper.safeTransferETH(to, value);
}
| /**
* @dev Withdraw
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
9287,
9493
]
} | 25,419 |
FeswaNFT | FeswaNFT.sol | 0x0ab276b92a6e6d3ecc8d5888d1b15effea223923 | Solidity | FeswaNFT | contract FeswaNFT is ERC721, Ownable {
using SafeMath for uint256;
using Address for address;
// Public variables
string public constant NAME = 'Feswap Pool NFT';
string public constant SYMBOL = 'FESN';
// Price offering duration: two weeks
// uint256 public constant OPEN_BID_D... | /**
* @title FeswaNFT contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/ | NatSpecMultiLine | setTokenURIPrefix | function setTokenURIPrefix(string memory prefix) public onlyOwner {
_setBaseURI(prefix);
}
| /**
* @dev @dev Set the prefix for the tokenURIs.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | GNU GPLv3 | ipfs://5f10921d1ef47680d6bd1f859d7e8e89d25d60017fee92343e8f3654c4c66769 | {
"func_code_index": [
9566,
9675
]
} | 25,420 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
94,
154
]
} | 25,421 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
237,
310
]
} | 25,422 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
534,
616
]
} | 25,423 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
895,
983
]
} | 25,424 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1647,
1726
]
} | 25,425 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
2039,
2141
]
} | 25,426 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryAdd | function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
| /**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
161,
388
]
} | 25,427 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | trySub | function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
| /**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
536,
735
]
} | 25,428 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryMul | function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// 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
... | /**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
885,
1393
]
} | 25,429 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryDiv | function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
| /**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1544,
1744
]
} | 25,430 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryMod | function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
| /**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1905,
2105
]
} | 25,431 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
2347,
2450
]
} | 25,432 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
| /**
* @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.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
2728,
2831
]
} | 25,433 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
| /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
3085,
3188
]
} | 25,434 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
| /**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
3484,
3587
]
} | 25,435 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting 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 (consu... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
4049,
4152
]
} | 25,436 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterp... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
4626,
4837
]
} | 25,437 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
| /**
* @dev Returns the integer division of two unsigned integers, reverting 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 ... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
5330,
5540
]
} | 25,438 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
6198,
6408
]
} | 25,439 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | isContract | function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
... | /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
606,
1033
]
} | 25,440 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address... | /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `tr... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1963,
2365
]
} | 25,441 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCall | function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
| /**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw ... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
3121,
3299
]
} | 25,442 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCall | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
3524,
3724
]
} | 25,443 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
4094,
4325
]
} | 25,444 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disa... | /**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
4576,
5111
]
} | 25,445 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionStaticCall | function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
5291,
5495
]
} | 25,446 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionStaticCall | function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.stat... | /**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
5682,
6109
]
} | 25,447 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionDelegateCall | function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
6291,
6496
]
} | 25,448 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionDelegateCall | function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.deleg... | /**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
6685,
7113
]
} | 25,449 |
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns t... | name | function name() external view returns (string memory);
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
100,
159
]
} | 25,450 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns t... | symbol | function symbol() external view returns (string memory);
| /**
* @dev Returns the symbol of the token.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
226,
287
]
} | 25,451 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns t... | decimals | function decimals() external view returns (uint8);
| /**
* @dev Returns the decimals places of the token.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
363,
418
]
} | 25,452 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | 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 () {
//address msgSender = _msgSe... | owner | function owner() public view virtual returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
578,
670
]
} | 25,453 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | 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 () {
//address msgSender = _msgSe... | 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.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1229,
1382
]
} | 25,454 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | 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 () {
//address msgSender = _msgSe... | 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.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1532,
1781
]
} | 25,455 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | name | function name() public view virtual override returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1002,
1107
]
} | 25,456 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | symbol | function symbol() public view virtual override returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1221,
1330
]
} | 25,457 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | decimals | function decimals() public view virtual override returns (uint8) {
return 18;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
1964,
2062
]
} | 25,458 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | totalSupply | function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
2122,
2235
]
} | 25,459 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | balanceOf | function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
2293,
2425
]
} | 25,460 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | 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.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
2633,
2813
]
} | 25,461 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
2871,
3027
]
} | 25,462 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | approve | function approve(address spender, uint256 amount) public virtual override onlyOwner() returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
3169,
3355
]
} | 25,463 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_ap... | /**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
3832,
4259
]
} | 25,464 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual onlyOwner returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
4663,
4893
]
} | 25,465 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual onlyOwner returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllow... | /**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
5391,
5783
]
} | 25,466 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 sende... | /**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
*... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
6268,
6877
]
} | 25,467 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | _burn | function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds ba... | /**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
7970,
8469
]
} | 25,468 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | _approve | function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amoun... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero a... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
9018,
9369
]
} | 25,469 | ||
HiddenGlobal | HiddenGlobal.sol | 0x1efbf2c1f843e83f69ed2aba689061c25e19f572 | Solidity | HiddenGlobal | contract HiddenGlobal is Context, IERC20, IERC20Metadata, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
strin... | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
| /**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* -... | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | MIT | ipfs://d0bac9d0edf091053d582e870ed4594359b31fd73daa219b16f8de41ce2cdcd6 | {
"func_code_index": [
9967,
10064
]
} | 25,470 | ||
AlgoLiteSale | contracts/AlgoLiteSale.sol | 0xa051e1117c6942c94cad161cfab8fae37757783f | Solidity | AlgoLiteSale | contract AlgoLiteSale is ReentrancyGuard {
/// Public sale amount (0.1 ETH)
uint256 private constant PUBLIC_SALE_AMOUNT = 0.1 * 10**18;
/// Private sale amount in tokens (1 Token)
uint256 private constant PRIVATE_SALE_AMOUNT = 1 * 10**18;
/// Mintable instance
IMintable private immutable mintab... | /// @author Iain Nash @isiain
/// @dev Minting Contract for Algo Lite Project by @jawn
/// @custom:warning UNAUDITED: Use at own risk | NatSpecSingleLine | purchase | function purchase() public payable nonReentrant {
require(numberSoldPublic < numberPublicSale, "No sale");
require(msg.value >= PUBLIC_SALE_AMOUNT, "Too low");
mintable.mint(msg.sender);
numberSoldPublic += 1;
console.log("has");
console.log(msg.value);
console.log("bal");
console.log(ad... | /// @dev Public purchase token, limited by number sold public, requires ETH value | NatSpecSingleLine | v0.8.6+commit.11564f7e | GNU GPLv3 | {
"func_code_index": [
1055,
1438
]
} | 25,471 | |
AlgoLiteSale | contracts/AlgoLiteSale.sol | 0xa051e1117c6942c94cad161cfab8fae37757783f | Solidity | AlgoLiteSale | contract AlgoLiteSale is ReentrancyGuard {
/// Public sale amount (0.1 ETH)
uint256 private constant PUBLIC_SALE_AMOUNT = 0.1 * 10**18;
/// Private sale amount in tokens (1 Token)
uint256 private constant PRIVATE_SALE_AMOUNT = 1 * 10**18;
/// Mintable instance
IMintable private immutable mintab... | /// @author Iain Nash @isiain
/// @dev Minting Contract for Algo Lite Project by @jawn
/// @custom:warning UNAUDITED: Use at own risk | NatSpecSingleLine | saleInfo | function saleInfo()
public
view
returns (
uint256,
uint256,
uint256,
uint256
)
{
return (
numberPublicSale,
numberSoldPublic,
numberPrivateSale,
numberSoldPrivate
);
}
| /// @dev Returns sales info
/// @return (numberpublic, soldpublic, numberprivate, soldprivate) | NatSpecSingleLine | v0.8.6+commit.11564f7e | GNU GPLv3 | {
"func_code_index": [
1543,
1866
]
} | 25,472 | |
AlgoLiteSale | contracts/AlgoLiteSale.sol | 0xa051e1117c6942c94cad161cfab8fae37757783f | Solidity | AlgoLiteSale | contract AlgoLiteSale is ReentrancyGuard {
/// Public sale amount (0.1 ETH)
uint256 private constant PUBLIC_SALE_AMOUNT = 0.1 * 10**18;
/// Private sale amount in tokens (1 Token)
uint256 private constant PRIVATE_SALE_AMOUNT = 1 * 10**18;
/// Mintable instance
IMintable private immutable mintab... | /// @author Iain Nash @isiain
/// @dev Minting Contract for Algo Lite Project by @jawn
/// @custom:warning UNAUDITED: Use at own risk | NatSpecSingleLine | purchaseWithTokens | function purchaseWithTokens(uint256 editions) public nonReentrant {
require(numberSoldPrivate + editions <= numberPrivateSale, "No sale");
require(editions > 0, "Min 1");
// Attempt to transfer tokens for mint
try
privateSaleToken.transferFrom(
msg.sender,
mintable.owner(... | /// @dev Purchase with token private sales fn
/// Requires: 1. token amount to transfer,
/// @param editions number of editions to purchase (needs to have same tokens) | NatSpecSingleLine | v0.8.6+commit.11564f7e | GNU GPLv3 | {
"func_code_index": [
2048,
2775
]
} | 25,473 | |
AlgoLiteSale | contracts/AlgoLiteSale.sol | 0xa051e1117c6942c94cad161cfab8fae37757783f | Solidity | AlgoLiteSale | contract AlgoLiteSale is ReentrancyGuard {
/// Public sale amount (0.1 ETH)
uint256 private constant PUBLIC_SALE_AMOUNT = 0.1 * 10**18;
/// Private sale amount in tokens (1 Token)
uint256 private constant PRIVATE_SALE_AMOUNT = 1 * 10**18;
/// Mintable instance
IMintable private immutable mintab... | /// @author Iain Nash @isiain
/// @dev Minting Contract for Algo Lite Project by @jawn
/// @custom:warning UNAUDITED: Use at own risk | NatSpecSingleLine | withdrawEth | function withdrawEth() public onlyMintableOwner {
(bool sent, ) = mintable.owner().call{
value: address(this).balance,
gas: 100_000
}("");
require(sent, "Failed to send Ether");
}
| /// @dev Withdraw ETH from public minting | NatSpecSingleLine | v0.8.6+commit.11564f7e | GNU GPLv3 | {
"func_code_index": [
2823,
3058
]
} | 25,474 | |
AlgoLiteSale | contracts/AlgoLiteSale.sol | 0xa051e1117c6942c94cad161cfab8fae37757783f | Solidity | AlgoLiteSale | contract AlgoLiteSale is ReentrancyGuard {
/// Public sale amount (0.1 ETH)
uint256 private constant PUBLIC_SALE_AMOUNT = 0.1 * 10**18;
/// Private sale amount in tokens (1 Token)
uint256 private constant PRIVATE_SALE_AMOUNT = 1 * 10**18;
/// Mintable instance
IMintable private immutable mintab... | /// @author Iain Nash @isiain
/// @dev Minting Contract for Algo Lite Project by @jawn
/// @custom:warning UNAUDITED: Use at own risk | NatSpecSingleLine | setSaleNumbers | function setSaleNumbers(uint256 newPublicNumber, uint256 newPrivateNumber)
public
{
numberPublicSale = newPublicNumber;
numberPrivateSale = newPrivateNumber;
}
| /// @dev Set number of NFTs that can be purchased
/// @param newPublicNumber new number allowed for public sale
/// @param newPrivateNumber new number allocated for private sale | NatSpecSingleLine | v0.8.6+commit.11564f7e | GNU GPLv3 | {
"func_code_index": [
3250,
3445
]
} | 25,475 | |
TMADispense | contracts\TMADispense.sol | 0xf13e9887c6fb528b5c00960116dbfe8db28534a7 | Solidity | IERC1155 | interface IERC1155 {
// function mint(address to, uint256 id, uint256 amount, bytes memory data) external;
function balanceOf(address a, uint256 id) external returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
by... | balanceOf | function balanceOf(address a, uint256 id) external returns (uint256);
| // function mint(address to, uint256 id, uint256 amount, bytes memory data) external; | LineComment | v0.6.12+commit.27d51765 | None | ipfs://6ab1f26a577192c6995bbad72d1226dce7cb4282791058f3f0be18afe074ca80 | {
"func_code_index": [
113,
187
]
} | 25,476 | ||
XToken | ERC20Burnable.sol | 0x59a82f0ff8e88804a34dd467b7061f1986fe1769 | Solidity | ERC20Burnable | abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Destroys `amount` tokens from `account`, deducting... | /**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burn | function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
| /**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/ | NatSpecMultiLine | v0.6.8+commit.0bbfe453 | MIT | ipfs://ae8763d5b7dccef1e5c85eb0e4132d1e9ebdbfbe0551c813cef8d5cdbac6bf59 | {
"func_code_index": [
155,
248
]
} | 25,477 |
XToken | ERC20Burnable.sol | 0x59a82f0ff8e88804a34dd467b7061f1986fe1769 | Solidity | ERC20Burnable | abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Destroys `amount` tokens from `account`, deducting... | /**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burnFrom | function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(
amount,
"ERC20: burn amount exceeds allowance"
);
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
| /**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/ | NatSpecMultiLine | v0.6.8+commit.0bbfe453 | MIT | ipfs://ae8763d5b7dccef1e5c85eb0e4132d1e9ebdbfbe0551c813cef8d5cdbac6bf59 | {
"func_code_index": [
550,
878
]
} | 25,478 |
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | CopyrightToken | function CopyrightToken(
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
... | /**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/ | NatSpecMultiLine | v0.4.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
851,
1400
]
} | 25,479 | |||
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | _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.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
1484,
2326
]
} | 25,480 | |||
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | 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.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
2532,
2644
]
} | 25,481 | |||
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | 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.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
2919,
3220
]
} | 25,482 | |||
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | 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.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
3484,
3660
]
} | 25,483 | |||
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | 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.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
4054,
4406
]
} | 25,484 | |||
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | 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.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
4576,
4950
]
} | 25,485 | |||
CopyrightToken | CopyrightToken.sol | 0x2a6e010c4fce2211d1f4d47461b9831a51d9e451 | Solidity | CopyrightToken | contract CopyrightToken is owned{
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
map... | 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.21-nightly.2018.3.1+commit.cf6720ea | bzzr://7e5ac80800b3747793791ecbfffd5eae272bff19c2ea40201e4fbb14c27e9600 | {
"func_code_index": [
5336,
5947
]
} | 25,486 | |||
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | Ownable | function Ownable() {
owner = msg.sender;
}
| /**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
261,
314
]
} | 25,487 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
637,
813
]
} | 25,488 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) pub... | /**
* @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));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return ... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
268,
613
]
} | 25,489 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) pub... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
819,
935
]
} | 25,490 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// require (_value <= _allowance);... | /**
* @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.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
392,
941
]
} | 25,491 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* ... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
1573,
1763
]
} | 25,492 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
2087,
2232
]
} | 25,493 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
2477,
2748
]
} | 25,494 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | MintableToken | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that ... | /**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/ | NatSpecMultiLine | mint | function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
| /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
483,
747
]
} | 25,495 | |
PuregoldToken | PuregoldToken.sol | 0x9b3e946e1a8ea0112b147af4e6e020752f2446bc | Solidity | MintableToken | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that ... | /**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/ | NatSpecMultiLine | finishMinting | function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
| /**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://e80546fb2091397d5904beadc379f3e38887bd948e9ca85db6d9269d3fd991ea | {
"func_code_index": [
864,
998
]
} | 25,496 | |
TokenMultiSender | TokenMultiSender.sol | 0xd92da4fe47a92955f15a71479daa370021e10b46 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () public {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://d67e10e210ef6ee265080e3d88c8eedc85ee1a04138bcc4787b46594fcd9ac09 | {
"func_code_index": [
641,
822
]
} | 25,497 |
TokenMultiSender | TokenMultiSender.sol | 0xd92da4fe47a92955f15a71479daa370021e10b46 | Solidity | TokenMultiSender | contract TokenMultiSender is Ownable{
event Message(string message);
token tokenReward;
address public addressOfTokenUsedAsReward;
function setTokenReward(address _addr) public onlyOwner {
tokenReward = token(_addr);
addressOfTokenUsedAsReward = _addr;
}
function distributeTokens... | // accept ETH | LineComment | v0.6.11+commit.5ef660b1 | BSD-3-Clause | ipfs://d67e10e210ef6ee265080e3d88c8eedc85ee1a04138bcc4787b46594fcd9ac09 | {
"func_code_index": [
806,
839
]
} | 25,498 | ||||
HXCCToken | HXCCToken.sol | 0x3ee2eea2277df647fa3f9c0e7af684ec625f7c9a | Solidity | HXCCToken | contract HXCCToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
string public name= "HuaXuChain";
uint8 public decimals=18;
string public symbol="HXCC";
string public version = '1.0.1';
function HXCCToken(ui... | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _valu... | /* Approves and then calls the receiving contract */ | Comment | v0.4.19+commit.c4cbbb05 | None | bzzr://2ff23ae1f057c206d0ed5d16536c76ec3761fc4a631cc8bc249e644a4d444510 | {
"func_code_index": [
961,
1359
]
} | 25,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.