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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
4026,
4161
]
} | 8,800 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
4675,
4846
]
} | 8,801 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | isContract | function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codeha... | /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
607,
1231
]
} | 8,802 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | 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 ... | toPayable | function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
| /**
* @dev Converts an `address` into `address payable`. Note that this is
* simply a type cast: the actual underlying value is not changed.
*
* _Available since v2.4.0._
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1443,
1575
]
} | 8,803 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success, ) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, re... | /**
* @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.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
2547,
2923
]
} | 8,804 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | IERC165 | interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This f... | supportsInterface | function supportsInterface(bytes4 interfaceId) external view returns (bool);
| /**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
374,
455
]
} | 8,805 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | IERC721 | contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
... | balanceOf | function balanceOf(address owner) public view returns (uint256 balance);
| /**
* @dev Returns the number of NFTs in `owner`'s account.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
387,
464
]
} | 8,806 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | IERC721 | contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
... | ownerOf | function ownerOf(uint256 tokenId) public view returns (address owner);
| /**
* @dev Returns the owner of the NFT specified by `tokenId`.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
551,
626
]
} | 8,807 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | IERC721 | contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
... | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId) public;
| /**
* @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
* another (`to`).
*
*
*
* Requirements:
* - `from`, `to` cannot be zero.
* - `tokenId` must be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this
* NFT by either {approve} or {setApp... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1017,
1098
]
} | 8,808 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | IERC721 | contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
... | transferFrom | function transferFrom(address from, address to, uint256 tokenId) public;
| /**
* @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
* another (`to`).
*
* Requirements:
* - If the caller is not `from`, it must be approved to move this NFT by
* either {approve} or {setApprovalForAll}.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1378,
1455
]
} | 8,809 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC165 | contract ERC165 is IERC165 {
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* @dev Mapping of interface ids to whether or not it's supported.
*/
mapping(bytes4 => bool) private _supportedIn... | supportsInterface | function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
| /**
* @dev See {IERC165-supportsInterface}.
*
* Time complexity O(1), guaranteed to always use less than 30 000 gas.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
711,
851
]
} | 8,810 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC165 | contract ERC165 is IERC165 {
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* @dev Mapping of interface ids to whether or not it's supported.
*/
mapping(bytes4 => bool) private _supportedIn... | _registerInterface | function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
| /**
* @dev Registers the contract as an implementer of the interface defined by
* `interfaceId`. Support of the actual ERC165 interface is automatic and
* registering its interface id is not required.
*
* See {IERC165-supportsInterface}.
*
* Requirements:
*
* - `interfaceId` cannot be the ERC165 inval... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1253,
1451
]
} | 8,811 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | Context | contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (addres... | _msgSender | function _msgSender() internal view returns (address payable) {
return msg.sender;
}
| // solhint-disable-previous-line no-empty-blocks | LineComment | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
265,
368
]
} | 8,812 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | IERC721Receiver | contract IERC721Receiver {
/**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a {IERC721-safeTransferFrom}. This function MUST return the function selector,
* otherwise the caller will revert the transaction. The selector... | onERC721Received | function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
| /**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a {IERC721-safeTransferFrom}. This function MUST return the function selector,
* otherwise the caller will revert the transaction. The selector to be
* returned can be obtained as `this.onE... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
912,
1040
]
} | 8,813 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | balanceOf | function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _ownedTokensCount[owner].current();
}
| /**
* @dev Gets the balance of the specified address.
* @param owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
2174,
2390
]
} | 8,814 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | ownerOf | function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
| /**
* @dev Gets the owner of the specified token ID.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
2611,
2844
]
} | 8,815 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | approve | function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
... | /**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param to address to be approved for the given to... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
3276,
3706
]
} | 8,816 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | getApproved | function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
| /**
* @dev Gets the approved address for a token ID, or zero if no address set
* Reverts if the token ID does not exist.
* @param tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
3994,
4203
]
} | 8,817 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | setApprovalForAll | function setApprovalForAll(address to, bool approved) public {
require(to != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][to] = approved;
emit ApprovalForAll(_msgSender(), to, approved);
}
| /**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf.
* @param to operator address to set the approval
* @param approved representing the status of the approval to be set
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
4499,
4758
]
} | 8,818 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | isApprovedForAll | function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
| /**
* @dev Tells whether an operator is approved by a given owner.
* @param owner owner address which you want to query the approval of
* @param operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
5083,
5235
]
} | 8,819 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | transferFrom | function transferFrom(address from, address to, uint256 tokenId) public {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transferFrom(from, to, tokenId);
}
| /**
* @dev Transfers the ownership of a given token ID to another address.
* Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
* Requires the msg.sender to be the owner, approved, or operator.
* @param from current owner of the token
* @param to address to receive the ownership of... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
5677,
5974
]
} | 8,820 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
| /**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
6631,
6770
]
} | 8,821 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransferFrom(from, to, tokenId, _data);
}
| /**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
7502,
7779
]
} | 8,822 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _safeTransferFrom | function _safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) internal {
_transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
| /**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
8493,
8770
]
} | 8,823 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _exists | function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
| /**
* @dev Returns whether the specified token exists.
* @param tokenId uint256 ID of the token to query the existence of
* @return bool whether the token exists
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
8967,
9127
]
} | 8,824 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _isApprovedOrOwner | function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
| /**
* @dev Returns whether the given spender can transfer a given token ID.
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of th... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
9492,
9830
]
} | 8,825 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _safeMint | function _safeMint(address to, uint256 tokenId) internal {
_safeMint(to, tokenId, "");
}
| /**
* @dev Internal function to safely mint a new token.
* Reverts if the given token ID already exists.
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
10366,
10473
]
} | 8,826 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _safeMint | function _safeMint(address to, uint256 tokenId, bytes memory _data) internal {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
| /**
* @dev Internal function to safely mint a new token.
* Reverts if the given token ID already exists.
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
11082,
11329
]
} | 8,827 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _mint | function _mint(address to, uint256 tokenId) internal {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_tokenOwner[tokenId] = to;
_ownedTokensCount[to].increment();
emit Transfer(address(0),to,tokenId);
}
| /**
* @dev Internal function to mint a new token.
* Reverts if the given token ID already exists.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
11579,
11917
]
} | 8,828 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _burn | function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner, "ERC721: burn of token that is not own");
_clearApproval(tokenId);
_ownedTokensCount[owner].decrement();
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
| /**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use {_burn} instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
12189,
12527
]
} | 8,829 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _burn | function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
| /**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* @param tokenId uint256 ID of the token being burned
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
12710,
12807
]
} | 8,830 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _transferFrom | function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_clearApproval(tokenId);
_ownedTokensCount[from].decrement();
_owne... | /**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the ... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
13188,
13652
]
} | 8,831 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _checkOnERC721Received | function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = to.call(abi.encodeWithSelector(
... | /**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* This is an internal detail of the `ERC721` contract and its use is deprecated.
* @param from address representing the previous owner of the giv... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
14299,
15383
]
} | 8,832 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721 | contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.s... | _clearApproval | function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
| /**
* @dev Private function to clear current approval of a given token ID.
* @param tokenId uint256 ID of the token to be transferred
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
15546,
15726
]
} | 8,833 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
| /**
* @dev Gets the token ID at a given index of the tokens list of the requested owner.
* @param owner address owning the tokens list to be accessed
* @param index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned b... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1528,
1765
]
} | 8,834 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | totalSupply | function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
| /**
* @dev Gets the total amount of tokens stored by the contract.
* @return uint256 representing the total amount of tokens
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1919,
2020
]
} | 8,835 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | tokenByIndex | function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
| /**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens.
* @param index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
2361,
2565
]
} | 8,836 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _transferFrom | function _transferFrom(address from, address to, uint256 tokenId) internal {
super._transferFrom(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
| /**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to transferFrom, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the to... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
2944,
3194
]
} | 8,837 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _mint | function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
_addTokenToAllTokensEnumeration(tokenId);
}
| /**
* @dev Internal function to mint a new token.
* Reverts if the given token ID already exists.
* @param to address the beneficiary that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
3454,
3661
]
} | 8,838 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _burn | function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
_removeTokenFromOwnerEnumeration(owner, tokenId);
// Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
_ownedTokensIndex[tokenId] = 0;
_removeTokenFromAllTo... | /**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use {ERC721-_burn} instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
3940,
4317
]
} | 8,839 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _tokensOfOwner | function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
return _ownedTokens[owner];
}
| /**
* @dev Gets the list of token IDs of the requested owner.
* @param owner address owning the tokens
* @return uint256[] List of token IDs owned by the requested address
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
4524,
4655
]
} | 8,840 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _addTokenToOwnerEnumeration | function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
| /**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
4951,
5142
]
} | 8,841 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _addTokenToAllTokensEnumeration | function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
| /**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
5338,
5507
]
} | 8,842 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _removeTokenFromOwnerEnumeration | function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
ui... | /**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
6129,
7282
]
} | 8,843 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Enumerable | contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
//... | _removeTokenFromAllTokensEnumeration | function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 tokenIndex = _a... | /**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
7572,
8659
]
} | 8,844 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Metadata | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*... | name | function name() external view returns (string memory) {
return _name;
}
| /**
* @dev Gets the token name.
* @return string representing the token name
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1078,
1168
]
} | 8,845 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Metadata | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*... | symbol | function symbol() external view returns (string memory) {
return _symbol;
}
| /**
* @dev Gets the token symbol.
* @return string representing the token symbol
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1278,
1372
]
} | 8,846 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Metadata | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*... | tokenURI | function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
// Even if there is a base URI, it is only appended to non-empty token-specific URIs
if (bytes(_... | /**
* @dev Returns the URI for a given token ID. May return an empty string.
*
* If the token's URI is non-empty and a base URI was set (via
* {_setBaseURI}), it will be added to the token ID's URI as a prefix.
*
* Reverts if the token ID does not exist.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
1680,
2242
]
} | 8,847 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Metadata | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*... | _setTokenURI | function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
| /**
* @dev Internal function to set the token URI for a given token.
*
* Reverts if the token ID does not exist.
*
* TIP: if all token IDs share a prefix (e.g. if your URIs look like
* `http://api.myproject.com/token/<id>`), use {_setBaseURI} to store
* it and save gas.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
2572,
2784
]
} | 8,848 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Metadata | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*... | _setBaseURI | function _setBaseURI(string memory baseURI) internal {
_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}.
*
* _Available since v2.5.0._
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
3000,
3095
]
} | 8,849 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Metadata | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*... | baseURI | function baseURI() external view returns (string memory) {
return _baseURI;
}
| /**
* @dev Returns the base URI set via {_setBaseURI}. This will be
* automatically added as a preffix in {tokenURI} to each token's URI, when
* they are non-empty.
*
* _Available since v2.5.0._
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
3331,
3427
]
} | 8,850 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721Metadata | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*... | _burn | function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
| /**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use _burn(uint256) instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned by the msg.sender
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
3724,
3976
]
} | 8,851 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev Give an account access to this role.
*/
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[accou... | add | function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
| /**
* @dev Give an account access to this role.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
156,
339
]
} | 8,852 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev Give an account access to this role.
*/
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[accou... | remove | function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
| /**
* @dev Remove an account's access to this role.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
414,
602
]
} | 8,853 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | Roles | library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev Give an account access to this role.
*/
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[accou... | has | function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
| /**
* @dev Check if an account has this role.
* @return bool
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
692,
900
]
} | 8,854 | ||
STIM | STIM.sol | 0x1afa08a06e676cb82e2090964ed0af4b0bf62594 | Solidity | ERC721MetadataMintable | contract ERC721MetadataMintable is ERC721, ERC721Metadata, MinterRole {
/**
* @dev Function to mint tokens.
* @param to The address that will receive the minted tokens.
* @param tokenId The token id to mint.
* @param tokenURI The token URI of the minted token.
* @return A boolean that... | mintWithTokenURI | function mintWithTokenURI(address to, uint256 tokenId, string memory tokenURI) public onlyMinter returns (bool) {
_mint(to, tokenId);
_setTokenURI(tokenId, tokenURI);
return true;
}
| /**
* @dev Function to mint tokens.
* @param to The address that will receive the minted tokens.
* @param tokenId The token id to mint.
* @param tokenURI The token URI of the minted token.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://92305ba72c3f2359d11a448f5f72ad0051986eb48f8b5f38484418c629085b37 | {
"func_code_index": [
374,
592
]
} | 8,855 | ||
MarsLocker | contracts/Mars26.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars26 | contract Mars26 is ERC20Burnable, Ownable {
using SafeMath for uint256;
uint256 public constant INITIAL_ALLOTMENT = 2026 * (10 ** 18);
uint256 public constant PRE_REVEAL_MULTIPLIER = 2;
uint256 private constant _SECONDS_IN_A_DAY = 86400;
uint256 private _emissionStartTimestamp;
uint256 privat... | /**
* Mars26 Contract
* @dev Extends standard ERC20 contract
*/ | NatSpecMultiLine | setMarsAddress | function setMarsAddress(address payable marsAddress_) public onlyOwner {
require(address(_mars) == address(0), "Already set");
_mars = Mars(marsAddress_);
}
| /**
* @dev Sets Mars contract address. Can only be called once by owner.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
1372,
1561
]
} | 8,856 | ||
MarsLocker | contracts/Mars26.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars26 | contract Mars26 is ERC20Burnable, Ownable {
using SafeMath for uint256;
uint256 public constant INITIAL_ALLOTMENT = 2026 * (10 ** 18);
uint256 public constant PRE_REVEAL_MULTIPLIER = 2;
uint256 private constant _SECONDS_IN_A_DAY = 86400;
uint256 private _emissionStartTimestamp;
uint256 privat... | /**
* Mars26 Contract
* @dev Extends standard ERC20 contract
*/ | NatSpecMultiLine | lastClaim | function lastClaim(uint256 tokenIndex) public view returns (uint256) {
require(_mars.ownerOf(tokenIndex) != address(0), "Owner cannot be 0 address");
require(tokenIndex < _mars.totalSupply(), "NFT at index has not been minted yet");
uint256 lastClaimed = uint256(_lastClaim[tokenIndex]) != 0 ? uint256(_last... | /**
* @dev Returns timestamp at which accumulated M26s have last been claimed for a {tokenIndex}.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
1678,
2093
]
} | 8,857 | ||
MarsLocker | contracts/Mars26.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars26 | contract Mars26 is ERC20Burnable, Ownable {
using SafeMath for uint256;
uint256 public constant INITIAL_ALLOTMENT = 2026 * (10 ** 18);
uint256 public constant PRE_REVEAL_MULTIPLIER = 2;
uint256 private constant _SECONDS_IN_A_DAY = 86400;
uint256 private _emissionStartTimestamp;
uint256 privat... | /**
* Mars26 Contract
* @dev Extends standard ERC20 contract
*/ | NatSpecMultiLine | accumulated | function accumulated(uint256 tokenIndex) public view returns (uint256) {
require(block.timestamp > _emissionStartTimestamp, "Emission has not started yet");
require(_mars.ownerOf(tokenIndex) != address(0), "Owner cannot be 0 address");
require(tokenIndex < _mars.totalSupply(), "NFT at index has not been min... | /**
* @dev Returns amount of accumulated M26s for {tokenIndex}.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
2180,
3526
]
} | 8,858 | ||
MarsLocker | contracts/Mars26.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | Mars26 | contract Mars26 is ERC20Burnable, Ownable {
using SafeMath for uint256;
uint256 public constant INITIAL_ALLOTMENT = 2026 * (10 ** 18);
uint256 public constant PRE_REVEAL_MULTIPLIER = 2;
uint256 private constant _SECONDS_IN_A_DAY = 86400;
uint256 private _emissionStartTimestamp;
uint256 privat... | /**
* Mars26 Contract
* @dev Extends standard ERC20 contract
*/ | NatSpecMultiLine | claim | function claim(uint256[] memory tokenIndices) public returns (uint256) {
require(block.timestamp > _emissionStartTimestamp, "Emission has not started yet");
uint256 totalClaimQty = 0;
for (uint i = 0; i < tokenIndices.length; i++) {
// Sanity check for non-minted index
require(tokenIndices[... | /**
* @dev Claim mints M26s and supports multiple token indices at once.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
3618,
4802
]
} | 8,859 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | doubleProxy | function doubleProxy() external view returns (address);
| /**
* @dev GET - The DoubleProxy of the DFO linked to this Contract
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
844,
904
]
} | 8,860 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setDoubleProxy | function setDoubleProxy(address newDoubleProxy) external;
| /**
* @dev SET - The DoubleProxy of the DFO linked to this Contract
* It can be done only through a Proposal in the Linked DFO
* @param newDoubleProxy the new DoubleProxy address
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
1118,
1180
]
} | 8,861 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setEthItemInteroperableInterfaceModel | function setEthItemInteroperableInterfaceModel(address ethItemInteroperableInterfaceModelAddress) external;
| /**
* @dev SET - The address of the Smart Contract whose code will serve as a model for all the EthItemERC20Wrappers (please see the eth-item-token-standard for further information).
* It can be done only through a Proposal in the Linked DFO
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
1451,
1563
]
} | 8,862 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setNativeModel | function setNativeModel(address nativeModelAddress) external;
| /**
* @dev SET - The address of the Native EthItem model.
* It can be done only through a Proposal in the Linked DFO
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
1709,
1775
]
} | 8,863 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setERC1155WrapperModel | function setERC1155WrapperModel(address erc1155WrapperModelAddress) external;
| /**
* @dev SET - The address of the ERC1155 NFT-Based EthItem model.
* It can be done only through a Proposal in the Linked DFO
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
1999,
2081
]
} | 8,864 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setERC20WrapperModel | function setERC20WrapperModel(address erc20WrapperModelAddress) external;
| /**
* @dev SET - The address of the Smart Contract whose code will serve as a model for all the Wrapped ERC20 EthItems.
* It can be done only through a Proposal in the Linked DFO
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
2372,
2450
]
} | 8,865 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setERC721WrapperModel | function setERC721WrapperModel(address erc721WrapperModelAddress) external;
| /**
* @dev SET - The address of the Smart Contract whose code will serve as a model for all the Wrapped ERC721 EthItems.
* It can be done only through a Proposal in the Linked DFO
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
2738,
2818
]
} | 8,866 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setMintFeePercentage | function setMintFeePercentage(uint256 mintFeePercentageNumerator, uint256 mintFeePercentageDenominator) external;
| /**
* @dev SET - The element useful to calculate the Percentage fee
* It can be done only through a Proposal in the Linked DFO
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
3055,
3173
]
} | 8,867 | ||
EthItemOrchestrator | contracts\orchestrator\IEthItemOrchestrator.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemOrchestrator | interface IEthItemOrchestrator is IERC721Receiver, IERC1155Receiver {
function factories() external view returns(address[] memory);
function factory() external view returns(address);
function setFactory(address newFactory) external;
function knowledgeBases() external view returns(address[] m... | setBurnFeePercentage | function setBurnFeePercentage(uint256 burnFeePercentageNumerator, uint256 burnFeePercentageDenominator) external;
| /**
* @dev SET - The element useful to calculate the Percentage fee
* It can be done only through a Proposal in the Linked DFO
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
3329,
3447
]
} | 8,868 | ||
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | function () payable{
createTokens();
}
| // Its a payable function works as a token factory. | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
974,
1043
]
} | 8,869 | ||
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | burnTokens | function burnTokens(uint256 _value) onlyOwner {
require(balances[msg.sender] >= _value && _value > 0 );
_totalSupply = _totalSupply.sub(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
}
| //allows owner to burn tokens that are not sold in a crowdsale | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
1298,
1578
]
} | 8,870 | |
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | createTokens | function createTokens() payable {
if(isMinting == true){
require(msg.value > 0);
uint256 tokens = msg.value.div(100000000000000).mul(RATE);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = _totalSupply.add(tokens);
owner.transfer(msg.value);
}
... | // This function creates Tokens | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
1628,
2085
]
} | 8,871 | |
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | balanceOf | function balanceOf(address _owner) constant returns(uint256){
return balances[_owner];
}
| // What is the balance of a particular account? | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
2460,
2579
]
} | 8,872 | |
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | transfer | function transfer(address _to, uint256 _value) returns(bool) {
require(balances[msg.sender] >= _value && _value > 0 );
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| // Transfer the balance from owner's account to another account | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
2659,
3011
]
} | 8,873 | |
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns(bool) {
require(allowed[_from][msg.sender] >= _value && balances[_from] >= _value && _value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[... | // Send _value amount of tokens from address _from to address _to
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account h... | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
3500,
3940
]
} | 8,874 | |
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | approve | function approve(address _spender, uint256 _value) returns(bool){
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| // Allow _spender to withdraw from your account, multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value. | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
4132,
4330
]
} | 8,875 | |
Hippy | Hippy.sol | 0xf57828f027d27ecae4f78bef6fbded840f14268d | Solidity | Hippy | contract Hippy {
string public constant name = "Hippy";
string public constant symbol = "HPY";
uint8 public constant decimals = 4;
uint public _totalSupply = 210000000000;
uint256 public RATE = 1;
bool public isMinting = false;
string public const... | // ERC20 Token Smart Contract | LineComment | allowance | function allowance(address _owner, address _spender) constant returns(uint256){
return allowed[_owner][_spender];
}
| // Returns the amount which _spender is still allowed to withdraw from _owner | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://32f1acfd026642e202c9fcfd07c25dbc322e2d1a472e6e825fc99d58b73ac987 | {
"func_code_index": [
4420,
4554
]
} | 8,876 | |
EthItemOrchestrator | node_modules\eth-item-token-standard\IERC1155Views.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IERC1155Views | interface IERC1155Views {
/**
* @dev Returns the total supply of the given token id
* @param objectId the id of the token whose availability you want to know
*/
function totalSupply(uint256 objectId) external view returns (uint256);
/**
* @dev Returns the name of the given to... | /**
* @title IERC1155Views - An optional utility interface to improve the ERC-1155 Standard.
* @dev This interface introduces some additional capabilities for ERC-1155 Tokens.
*/ | NatSpecMultiLine | totalSupply | function totalSupply(uint256 objectId) external view returns (uint256);
| /**
* @dev Returns the total supply of the given token id
* @param objectId the id of the token whose availability you want to know
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
188,
264
]
} | 8,877 |
EthItemOrchestrator | node_modules\eth-item-token-standard\IERC1155Views.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IERC1155Views | interface IERC1155Views {
/**
* @dev Returns the total supply of the given token id
* @param objectId the id of the token whose availability you want to know
*/
function totalSupply(uint256 objectId) external view returns (uint256);
/**
* @dev Returns the name of the given to... | /**
* @title IERC1155Views - An optional utility interface to improve the ERC-1155 Standard.
* @dev This interface introduces some additional capabilities for ERC-1155 Tokens.
*/ | NatSpecMultiLine | name | function name(uint256 objectId) external view returns (string memory);
| /**
* @dev Returns the name of the given token id
* @param objectId the id of the token whose name you want to know
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
410,
485
]
} | 8,878 |
EthItemOrchestrator | node_modules\eth-item-token-standard\IERC1155Views.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IERC1155Views | interface IERC1155Views {
/**
* @dev Returns the total supply of the given token id
* @param objectId the id of the token whose availability you want to know
*/
function totalSupply(uint256 objectId) external view returns (uint256);
/**
* @dev Returns the name of the given to... | /**
* @title IERC1155Views - An optional utility interface to improve the ERC-1155 Standard.
* @dev This interface introduces some additional capabilities for ERC-1155 Tokens.
*/ | NatSpecMultiLine | symbol | function symbol(uint256 objectId) external view returns (string memory);
| /**
* @dev Returns the symbol of the given token id
* @param objectId the id of the token whose symbol you want to know
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
635,
712
]
} | 8,879 |
EthItemOrchestrator | node_modules\eth-item-token-standard\IERC1155Views.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IERC1155Views | interface IERC1155Views {
/**
* @dev Returns the total supply of the given token id
* @param objectId the id of the token whose availability you want to know
*/
function totalSupply(uint256 objectId) external view returns (uint256);
/**
* @dev Returns the name of the given to... | /**
* @title IERC1155Views - An optional utility interface to improve the ERC-1155 Standard.
* @dev This interface introduces some additional capabilities for ERC-1155 Tokens.
*/ | NatSpecMultiLine | decimals | function decimals(uint256 objectId) external view returns (uint256);
| /**
* @dev Returns the decimals of the given token id
* @param objectId the id of the token whose decimals you want to know
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
866,
939
]
} | 8,880 |
EthItemOrchestrator | node_modules\eth-item-token-standard\IERC1155Views.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IERC1155Views | interface IERC1155Views {
/**
* @dev Returns the total supply of the given token id
* @param objectId the id of the token whose availability you want to know
*/
function totalSupply(uint256 objectId) external view returns (uint256);
/**
* @dev Returns the name of the given to... | /**
* @title IERC1155Views - An optional utility interface to improve the ERC-1155 Standard.
* @dev This interface introduces some additional capabilities for ERC-1155 Tokens.
*/ | NatSpecMultiLine | uri | function uri(uint256 objectId) external view returns (string memory);
| /**
* @dev Returns the uri of the given token id
* @param objectId the id of the token whose uri you want to know
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
1083,
1157
]
} | 8,881 |
MarsLocker | contracts/MarsStorage.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | MarsStorage | contract MarsStorage is Ownable {
using SafeMath for uint256;
// hash code: 0x12 (SHA-2) and digest length: 0x20 (32 bytes / 256 bits)
bytes2 public constant MULTIHASH_PREFIX = 0x1220;
// IPFS CID Version: v0
uint256 public constant CID_VERSION = 0;
// IPFS v0 CIDs in hexadecimal without m... | /**
* @title MarsStorage contract
*/ | NatSpecMultiLine | initialSequenceTokenCID | function initialSequenceTokenCID(uint256 initialSequenceIndex) public view returns (string memory) {
bytes memory tokenCIDHex = abi.encodePacked(
MULTIHASH_PREFIX,
_intitialSequenceTokenHashes[initialSequenceIndex]
);
string memory tokenCID = _toBase58(tokenCIDHex);
return tokenCID;
}
| /**
* @dev Returns the IPFS v0 CID of {initialSequenceIndex}.
*
* The returned values can be concatenated and hashed using SHA2-256 to verify the
* provenance hash.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
894,
1244
]
} | 8,882 | ||
MarsLocker | contracts/MarsStorage.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | MarsStorage | contract MarsStorage is Ownable {
using SafeMath for uint256;
// hash code: 0x12 (SHA-2) and digest length: 0x20 (32 bytes / 256 bits)
bytes2 public constant MULTIHASH_PREFIX = 0x1220;
// IPFS CID Version: v0
uint256 public constant CID_VERSION = 0;
// IPFS v0 CIDs in hexadecimal without m... | /**
* @title MarsStorage contract
*/ | NatSpecMultiLine | setInitialSequenceTokenHashes | function setInitialSequenceTokenHashes(bytes32[] memory tokenHashes) onlyOwner public {
setInitialSequenceTokenHashesAtIndex(_intitialSequenceTokenHashes.length, tokenHashes);
}
| /**
* @dev Sets token hashes in the initially set order as verifiable through
* {_provenanceHash}.
*
* Provided {tokenHashes} are IPFS v0 CIDs in hexadecimal without the prefix 0x1220
* and ordered in the initial sequence.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
1507,
1700
]
} | 8,883 | ||
MarsLocker | contracts/MarsStorage.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | MarsStorage | contract MarsStorage is Ownable {
using SafeMath for uint256;
// hash code: 0x12 (SHA-2) and digest length: 0x20 (32 bytes / 256 bits)
bytes2 public constant MULTIHASH_PREFIX = 0x1220;
// IPFS CID Version: v0
uint256 public constant CID_VERSION = 0;
// IPFS v0 CIDs in hexadecimal without m... | /**
* @title MarsStorage contract
*/ | NatSpecMultiLine | setInitialSequenceTokenHashesAtIndex | function setInitialSequenceTokenHashesAtIndex(
uint256 startIndex,
bytes32[] memory tokenHashes
) public onlyOwner {
require(startIndex <= _intitialSequenceTokenHashes.length);
for (uint256 i = 0; i < tokenHashes.length; i++) {
if ((i + startIndex) >= _intitialSequenceTokenHashes.length) {
... | /**
* @dev Sets token hashes in the initially set order starting at {startIndex}.
*/ | NatSpecMultiLine | v0.8.3+commit.8d00100c | {
"func_code_index": [
1801,
2410
]
} | 8,884 | ||
MarsLocker | contracts/MarsStorage.sol | 0x64200351e787b33cd7c518a93fc24d780092f727 | Solidity | MarsStorage | contract MarsStorage is Ownable {
using SafeMath for uint256;
// hash code: 0x12 (SHA-2) and digest length: 0x20 (32 bytes / 256 bits)
bytes2 public constant MULTIHASH_PREFIX = 0x1220;
// IPFS CID Version: v0
uint256 public constant CID_VERSION = 0;
// IPFS v0 CIDs in hexadecimal without m... | /**
* @title MarsStorage contract
*/ | NatSpecMultiLine | _toBase58 | function _toBase58(bytes memory source)
internal
pure
returns (string memory)
{
if (source.length == 0) return new string(0);
uint8[] memory digits = new uint8[](46);
digits[0] = 0;
uint8 digitlength = 1;
for (uint256 i = 0; i < source.length; ++i) {
uint256 carry = uint8(source[... | // Source: verifyIPFS (https://github.com/MrChico/verifyIPFS/blob/master/contracts/verifyIPFS.sol)
// @author Martin Lundfall (martin.lundfall@consensys.net)
// @dev Converts hex string to base 58 | LineComment | v0.8.3+commit.8d00100c | {
"func_code_index": [
2621,
3458
]
} | 8,885 | ||
EthItemOrchestrator | contracts\models\common\IEthItemModelBase.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemModelBase | interface IEthItemModelBase is IEthItemMainInterface {
/**
* @dev Contract Initialization, the caller of this method should be a Contract containing the logic to provide the EthItemERC20WrapperModel to be used to create ERC20-based objectIds
* @param name the chosen name for this NFT
* @param s... | /**
* @dev This interface contains the commonn data provided by all the EthItem models
*/ | NatSpecMultiLine | init | function init(string calldata name, string calldata symbol) external;
| /**
* @dev Contract Initialization, the caller of this method should be a Contract containing the logic to provide the EthItemERC20WrapperModel to be used to create ERC20-based objectIds
* @param name the chosen name for this NFT
* @param symbol the chosen symbol (Ticker) for this NFT
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
376,
450
]
} | 8,886 |
EthItemOrchestrator | contracts\models\common\IEthItemModelBase.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemModelBase | interface IEthItemModelBase is IEthItemMainInterface {
/**
* @dev Contract Initialization, the caller of this method should be a Contract containing the logic to provide the EthItemERC20WrapperModel to be used to create ERC20-based objectIds
* @param name the chosen name for this NFT
* @param s... | /**
* @dev This interface contains the commonn data provided by all the EthItem models
*/ | NatSpecMultiLine | modelVersion | function modelVersion() external pure returns(uint256 modelVersionNumber);
| /**
* @return modelVersionNumber The version number of the Model, it should be progressive
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
564,
643
]
} | 8,887 |
EthItemOrchestrator | contracts\models\common\IEthItemModelBase.sol | 0xf15aaae073f578d3b7c086ca7cb7901424120d51 | Solidity | IEthItemModelBase | interface IEthItemModelBase is IEthItemMainInterface {
/**
* @dev Contract Initialization, the caller of this method should be a Contract containing the logic to provide the EthItemERC20WrapperModel to be used to create ERC20-based objectIds
* @param name the chosen name for this NFT
* @param s... | /**
* @dev This interface contains the commonn data provided by all the EthItem models
*/ | NatSpecMultiLine | factory | function factory() external view returns(address factoryAddress);
| /**
* @return factoryAddress the address of the Contract which initialized this EthItem
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://b99a999149762852e582b93f647f10413da2a95e8285d970af4f78d7800500c4 | {
"func_code_index": [
754,
824
]
} | 8,888 |
TheBillionCoinCash | TheBillionCoinCash.sol | 0x9f671e9f177e2f4e955283ee8fb45cdbb77148bd | Solidity | TheBillionCoinCash | contract TheBillionCoinCash is StandardToken {
string public constant name = "TheBillionCoinCash";
string public constant symbol = "TBCC";
uint256 public constant decimals = 18;
string public version = "1.0";
uint256 public constant total = 10000 * (10**7) * 10**decimals; // 20 *10^7 TBCC total
... | TheBillionCoinCash | function TheBillionCoinCash() public {
balances[msg.sender] = total;
Transfer(0x0, msg.sender, total);
}
| // 20 *10^7 TBCC total | LineComment | v0.4.25+commit.59dbf8f1 | bzzr://5680f4da9904f00907beba0d9155c5f1cd6637784db9c0535c759d858f2c0d28 | {
"func_code_index": [
318,
438
]
} | 8,889 | |||
PaparazzoToken | PaparazzoToken.sol | 0x56bf111e4dc6da3ac0ce6f364da7223993f2f310 | Solidity | PaparazzoToken | contract PaparazzoToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public startDate;
uint public bonusEnds;
uint public endDate;
mapping(address => uint) balances;
mapping(address =>... | function () public payable {
require(now >= startDate && now <= endDate);
uint tokens;
if (now <= bonusEnds) {
tokens = msg.value * 10000;
} else {
tokens = msg.value * 1000;
}
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_tota... | // ------------------------------------------------------------------------
// 1000 Paparazzo Tokens per 1 ETH
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | bzzr://d470e0979a6d049a94e26803bb19ec696bd8e48aef899b99fa1112c6a86d7e9e | {
"func_code_index": [
2378,
2850
]
} | 8,890 | ||||
PaparazzoToken | PaparazzoToken.sol | 0x56bf111e4dc6da3ac0ce6f364da7223993f2f310 | Solidity | PaparazzoToken | contract PaparazzoToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public startDate;
uint public bonusEnds;
uint public endDate;
mapping(address => uint) balances;
mapping(address =>... | transferAnyERC20Token | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
| // ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------ | LineComment | v0.4.18+commit.9cf6e910 | bzzr://d470e0979a6d049a94e26803bb19ec696bd8e48aef899b99fa1112c6a86d7e9e | {
"func_code_index": [
3085,
3274
]
} | 8,891 | |||
MetaScyra | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | name | function name() external view returns (string memory);
| /**
* @dev Returns the token collection name.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
106,
165
]
} | 8,892 |
MetaScyra | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | symbol | function symbol() external view returns (string memory);
| /**
* @dev Returns the token collection symbol.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
236,
297
]
} | 8,893 |
MetaScyra | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenURI | function tokenURI(uint256 tokenId) external view returns (string memory);
| /**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
398,
476
]
} | 8,894 |
MetaScyra | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | IERC721Enumerable | interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanc... | /**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the total amount of tokens stored by the contract.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
132,
192
]
} | 8,895 |
MetaScyra | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | IERC721Enumerable | interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanc... | /**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index)
external
view
returns (uint256 tokenId);
| /**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
375,
506
]
} | 8,896 |
MetaScyra | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0xd7c57fc28f72cc8ffbd635155d924f0ac3f03f8e | Solidity | IERC721Enumerable | interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanc... | /**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 index) external view returns (uint256);
| /**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | MIT | ipfs://672fc76424cd92c353e6de815b9bcc53701f37d5371e3774b462983f8ad2f3fe | {
"func_code_index": [
682,
756
]
} | 8,897 |
LaunchpadCrowdsaleWithVesting | contracts/CappedTokenSoldCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | CappedTokenSoldCrowdsaleHelper | contract CappedTokenSoldCrowdsaleHelper {
using SafeMath for uint256;
uint256 private _tokenCap;
/**
* @param tokenCap_ Max amount of tokens to be sold
*/
constructor(uint256 tokenCap_) {
require(tokenCap_ > 0, "CappedTokenSoldHelper: zero cap");
_tokenCap = tokenCap_;
}
... | /**
* @title CappedTokenSoldCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale with a limit for total tokens sold.
*/ | NatSpecMultiLine | tokenCap | function tokenCap() public view returns (uint256 tokenCap_) {
tokenCap_ = _tokenCap;
}
| /**
* @return tokenCap_ the token cap of the crowdsale.
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
620,
722
]
} | 8,898 | ||
LaunchpadCrowdsaleWithVesting | contracts/CappedTokenSoldCrowdsaleHelper.sol | 0x6557d383b209fc901c57da8dffd15e2689e789ed | Solidity | CappedTokenSoldCrowdsaleHelper | contract CappedTokenSoldCrowdsaleHelper {
using SafeMath for uint256;
uint256 private _tokenCap;
/**
* @param tokenCap_ Max amount of tokens to be sold
*/
constructor(uint256 tokenCap_) {
require(tokenCap_ > 0, "CappedTokenSoldHelper: zero cap");
_tokenCap = tokenCap_;
}
... | /**
* @title CappedTokenSoldCrowdsaleHelper
* @author Enjinstarter
* @dev Helper for crowdsale with a limit for total tokens sold.
*/ | NatSpecMultiLine | tokenCapReached | function tokenCapReached(uint256 tokensSold)
external
view
returns (bool tokenCapReached_)
{
tokenCapReached_ = (tokensSold >= _tokenCap);
}
| /**
* @dev Checks whether the token cap has been reached.
* @return tokenCapReached_ Whether the token cap was reached
*/ | NatSpecMultiLine | v0.7.6+commit.7338295f | {
"func_code_index": [
865,
1049
]
} | 8,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.