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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | ERC1155 | contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address =>... | /**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/ | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
| /**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` a... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
12916,
13142
]
} | 27,100 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | balanceOf | function balanceOf(address owner) external view returns (uint256 balance);
| /**
* @dev Returns the number of tokens in ``owner``'s account.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
719,
798
]
} | 27,101 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | ownerOf | function ownerOf(uint256 tokenId) external view returns (address owner);
| /**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
944,
1021
]
} | 27,102 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | safeTransferFrom | function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
| /**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token mus... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
1733,
1850
]
} | 27,103 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | transferFrom | function transferFrom(
address from,
address to,
uint256 tokenId
) external;
| /**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If th... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
2376,
2489
]
} | 27,104 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | approve | function approve(address to, uint256 tokenId) external;
| /**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
2962,
3022
]
} | 27,105 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | getApproved | function getApproved(uint256 tokenId) external view returns (address operator);
| /**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
3176,
3260
]
} | 27,106 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | setApprovalForAll | function setApprovalForAll(address operator, bool _approved) external;
| /**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
3587,
3662
]
} | 27,107 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | isApprovedForAll | function isApprovedForAll(address owner, address operator) external view returns (bool);
| /**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
3813,
3906
]
} | 27,108 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | safeTransferFrom | function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
| /**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {appro... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
4483,
4630
]
} | 27,109 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryAdd | function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
| /**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
161,
388
]
} | 27,110 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | trySub | function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
| /**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
536,
735
]
} | 27,111 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryMul | function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
... | /**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
885,
1393
]
} | 27,112 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryDiv | function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
| /**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
1544,
1744
]
} | 27,113 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryMod | function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
| /**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
1905,
2105
]
} | 27,114 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
2347,
2450
]
} | 27,115 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
2728,
2831
]
} | 27,116 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
| /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
3085,
3188
]
} | 27,117 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
| /**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
3484,
3587
]
} | 27,118 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consu... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
4049,
4152
]
} | 27,119 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | sub | function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterp... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
4626,
4871
]
} | 27,120 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | div | function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
| /**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an ... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
5364,
5608
]
} | 27,121 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) ... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mod | function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
6266,
6510
]
} | 27,122 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | Strings | library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT ... | /**
* @dev String operations.
*/ | NatSpecMultiLine | toString | function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 ... | /**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
184,
912
]
} | 27,123 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | Strings | library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT ... | /**
* @dev String operations.
*/ | NatSpecMultiLine | toHexString | function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
| /**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
1017,
1362
]
} | 27,124 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | Strings | library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT ... | /**
* @dev String operations.
*/ | NatSpecMultiLine | toHexString | function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
... | /**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
1485,
1941
]
} | 27,125 |
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | revealNow | function revealNow()
external
onlyOwner
{
reveal = true;
}
| /*
* Function to reveal all NFTs
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
843,
946
]
} | 27,126 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | mint | function mint(address to, uint32 count) internal {
if (count > 1) {
uint256[] memory ids = new uint256[](uint256(count));
uint256[] memory amounts = new uint256[](uint256(count));
for (uint32 i = 0; i < count; i++) {
ids[i] = totalSupply + i;
amounts[i] = 1;
... | /*
* Function to mint NFTs
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
999,
1523
]
} | 27,127 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | setIsActive | function setIsActive(
bool _isActive
)
external
onlyOwner
{
isActive = _isActive;
}
| /*
* Function setIsActive to activate/desactivate the smart contract
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
1618,
1760
]
} | 27,128 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | setURIs | function setURIs(
string memory _blindURI,
string memory _URI
)
external
onlyOwner
{
blindURI = _blindURI;
baseURI = _URI;
}
| /*
* Function to set Base and Blind URI
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
1823,
2025
]
} | 27,129 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | breed | function breed(
uint256 idSecond
)
public
payable
{
require(NFTPrice == msg.value, "Ether value sent is not correct");
require(isActive, "Contract is not active");
require(BAYC.balanceOf(msg.sender)>=1,"You are not BAYC");
require(!hasBreed[idSecond],"1 MGDC can breed only once");... | /*
* Function to mint new NFTs when breeding
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
2680,
3234
]
} | 27,130 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | mintByOwner | function mintByOwner(
address _to
)
public
onlyOwner
{
require(giveawayCount.add(1)<=1,"Cannot do more giveaway");
mint(_to,1);
giveawayCount=giveawayCount.add(1);
}
| /*
* Function to mint all NFTs to create the collection
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
3321,
3562
]
} | 27,131 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | uri | function uri(
uint256 _tokenId
)
public
view
virtual
override
returns (string memory)
{
require(_tokenId<totalSupply, "ERC1155Metadata: URI query for nonexistent token");
if (!reveal) {
return string(abi.encodePacked(blindURI));
} else {
return stri... | /*
* Function to get token URI of given token ID
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
3637,
4083
]
} | 27,132 | ||
MGDCbreedBAYC | @openzeppelin/contracts/token/ERC1155/ERC1155.sol | 0x563cb938f8945d01c1795bb7e457123e65983c06 | Solidity | MGDCbreedBAYC | contract MGDCbreedBAYC is ERC1155, Ownable {
string public constant name = "Bored Kid";
string public constant symbol = "BKid";
uint256 public NFTPrice = 250000000000000000;
using SafeMath for uint256;
using Strings for uint256;
uint256 public totalSupply = 0;
string private baseURI;
... | withdraw | function withdraw(
)
public
onlyOwner
{
uint balance = address(this).balance;
payable(address(0xbD7D5f86f2343aDe4108b638F34f01ad1986b8A5)).transfer(balance);
}
| /*
* Function to withdraw collected amount during minting by the owner
*/ | Comment | v0.8.4+commit.c7e474f2 | None | ipfs://466c4b071e867d164a5adec752e29c006da37e4005e639aaa96813b5b09d4112 | {
"func_code_index": [
4180,
4398
]
} | 27,133 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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) {... | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
248,
428
]
} | 27,134 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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) {... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
695,
833
]
} | 27,135 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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) {... | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
1120,
1311
]
} | 27,136 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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) {... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
1554,
2017
]
} | 27,137 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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) {... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (co... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
2475,
2609
]
} | 27,138 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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) {... | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid ... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
3087,
3363
]
} | 27,139 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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 (consuming all... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
3810,
3942
]
} | 27,140 | ||
MONA__Farming | SafeMath.sol | 0x1c0e62e20a400a9d79cd7bfdb3cc938791d5cae4 | 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 opcode to r... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | Unlicense | bzzr://e6a5441ba89f633efd29951f28819caeeddd601f3ec372018072923022e85b4e | {
"func_code_index": [
4409,
4576
]
} | 27,141 | ||
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.c... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
Gas optimization: this is cheaper than asserting 'a' not being zero, but the
benefit is lost if 'b' is also tested.
See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if(a == 0) {
return 0;
c = a * b;
... | /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
90,
492
]
} | 27,142 | ||
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.c... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
573,
855
]
} | 27,143 | ||
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.c... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
966,
1094
]
} | 27,144 | ||
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.c... | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
1159,
1305
]
} | 27,145 | ||
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev Total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
219,
315
]
} | 27,146 |
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
... | /**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
481,
859
]
} | 27,147 |
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
1072,
1184
]
} | 27,148 |
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom (
address _from,
address _to,
uint256 _value
) public returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_t... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
410,
961
]
} | 27,149 |
EasyGame | EasyGame.sol | 0x3a211f6dba8ac7fd30ee95b2f79120225f6920ad | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(
address _spender,
uint256 _subtractedValue
ublic returns (bool)
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue)... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender T... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | None | bzzr://aae86f3a977660115599fb9001f80c4681cbf7680dda77bf53ba1406aa377d0f | {
"func_code_index": [
2196,
2689
]
} | 27,150 |
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | getNode | function getNode(uint256 nodeNum) public view override returns (INode) {
return _nodes[nodeNum];
}
| /**
* @notice Get the address of the Node contract for the given node
* @param nodeNum Index of the node
* @return Address of the Node contract
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
1022,
1136
]
} | 27,151 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | getStakerAddress | function getStakerAddress(uint256 stakerNum) public view override returns (address) {
return _stakerList[stakerNum];
}
| /**
* @notice Get the address of the staker at the given index
* @param stakerNum Index of the staker
* @return Address of the staker
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
1299,
1433
]
} | 27,152 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | isStaked | function isStaked(address staker) public view override returns (bool) {
return _stakerMap[staker].isStaked;
}
| /**
* @notice Check whether the given staker is staked
* @param staker Staker address to check
* @return True or False for whether the staker was staked
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
1615,
1740
]
} | 27,153 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | latestStakedNode | function latestStakedNode(address staker) public view override returns (uint256) {
return _stakerMap[staker].latestStakedNode;
}
| /**
* @notice Get the latest staked node of the given staker
* @param staker Staker address to lookup
* @return Latest node staked of the staker
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
1914,
2058
]
} | 27,154 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | currentChallenge | function currentChallenge(address staker) public view override returns (address) {
return _stakerMap[staker].currentChallenge;
}
| /**
* @notice Get the current challenge of the given staker
* @param staker Staker address to lookup
* @return Current challenge of the staker
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
2230,
2374
]
} | 27,155 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | amountStaked | function amountStaked(address staker) public view override returns (uint256) {
return _stakerMap[staker].amountStaked;
}
| /**
* @notice Get the amount staked of the given staker
* @param staker Staker address to lookup
* @return Amount staked of the staker
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
2538,
2674
]
} | 27,156 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | zombieAddress | function zombieAddress(uint256 zombieNum) public view override returns (address) {
return _zombies[zombieNum].stakerAddress;
}
| /**
* @notice Get the original staker address of the zombie at the given index
* @param zombieNum Index of the zombie to lookup
* @return Original staker address of the zombie
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
2879,
3021
]
} | 27,157 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | zombieLatestStakedNode | function zombieLatestStakedNode(uint256 zombieNum) public view override returns (uint256) {
return _zombies[zombieNum].latestStakedNode;
}
| /**
* @notice Get Latest node that the given zombie at the given index is staked on
* @param zombieNum Index of the zombie to lookup
* @return Latest node that the given zombie is staked on
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
3240,
3394
]
} | 27,158 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | zombieCount | function zombieCount() public view override returns (uint256) {
return _zombies.length;
}
| /// @return Current number of un-removed zombies | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
3449,
3554
]
} | 27,159 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | withdrawableFunds | function withdrawableFunds(address owner) public view override returns (uint256) {
return _withdrawableFunds[owner];
}
| /**
* @notice Get the amount of funds withdrawable by the given address
* @param owner Address to check the funds of
* @return Amount of funds withdrawable by owner
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
4017,
4151
]
} | 27,160 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | firstUnresolvedNode | function firstUnresolvedNode() public view override returns (uint256) {
return _firstUnresolvedNode;
}
| /**
* @return Index of the first unresolved node
* @dev If all nodes have been resolved, this will be latestNodeCreated + 1
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
4299,
4417
]
} | 27,161 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | latestConfirmed | function latestConfirmed() public view override returns (uint256) {
return _latestConfirmed;
}
| /// @return Index of the latest confirmed node | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
4470,
4580
]
} | 27,162 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | latestNodeCreated | function latestNodeCreated() public view override returns (uint256) {
return _latestNodeCreated;
}
| /// @return Index of the latest rollup node created | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
4638,
4752
]
} | 27,163 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | lastStakeBlock | function lastStakeBlock() public view override returns (uint256) {
return _lastStakeBlock;
}
| /// @return Ethereum block that the most recent stake was created | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
4824,
4932
]
} | 27,164 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | stakerCount | function stakerCount() public view override returns (uint256) {
return _stakerList.length;
}
| /// @return Number of active stakers currently staked | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
4992,
5100
]
} | 27,165 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | initializeCore | function initializeCore(INode initialNode) internal {
_nodes[0] = initialNode;
_firstUnresolvedNode = 1;
}
| /**
* @notice Initialize the core with an initial node
* @param initialNode Initial node to start the chain with
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
5237,
5367
]
} | 27,166 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | nodeCreated | function nodeCreated(INode node, bytes32 nodeHash) internal {
_latestNodeCreated++;
_nodes[_latestNodeCreated] = node;
_nodeHashes[_latestNodeCreated] = nodeHash;
}
| /**
* @notice React to a new node being created by storing it an incrementing the latest node counter
* @param node Node that was newly created
* @param nodeHash The hash of said node
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
5580,
5776
]
} | 27,167 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | getNodeHash | function getNodeHash(uint256 index) public view override returns (bytes32) {
return _nodeHashes[index];
}
| /// @return Node hash as of this node number | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
5827,
5948
]
} | 27,168 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | updateLatestNodeCreated | function updateLatestNodeCreated(uint256 newLatestNodeCreated) internal {
_latestNodeCreated = newLatestNodeCreated;
}
| /**
* @notice Update the latest node created
* @param newLatestNodeCreated New value for the latest node created
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
6177,
6311
]
} | 27,169 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | rejectNextNode | function rejectNextNode() internal {
destroyNode(_firstUnresolvedNode);
_firstUnresolvedNode++;
}
| /// @notice Reject the next unresolved node | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
6361,
6482
]
} | 27,170 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | confirmNextNode | function confirmNextNode() internal {
destroyNode(_latestConfirmed);
_latestConfirmed = _firstUnresolvedNode;
_firstUnresolvedNode++;
}
| /// @notice Confirm the next unresolved node | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
6533,
6700
]
} | 27,171 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | confirmLatestNode | function confirmLatestNode() internal {
destroyNode(_latestConfirmed);
uint256 latestNode = _latestNodeCreated;
_latestConfirmed = latestNode;
_firstUnresolvedNode = latestNode + 1;
}
| /// @notice Confirm the next unresolved node | NatSpecSingleLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
6751,
6974
]
} | 27,172 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | createNewStake | function createNewStake(address payable stakerAddress, uint256 depositAmount) internal {
uint256 stakerIndex = _stakerList.length;
_stakerList.push(stakerAddress);
_stakerMap[stakerAddress] = Staker(
stakerIndex,
_latestConfirmed,
depositAmount,
address(0),
true
)... | /**
* @notice Create a new stake
* @param stakerAddress Address of the new staker
* @param depositAmount Stake amount of the new staker
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
7139,
7546
]
} | 27,173 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | inChallenge | function inChallenge(address stakerAddress1, address stakerAddress2)
internal
view
returns (address)
{
Staker storage staker1 = _stakerMap[stakerAddress1];
Staker storage staker2 = _stakerMap[stakerAddress2];
address challenge = staker1.currentChallenge;
require(challenge == staker2.currentC... | /**
* @notice Check to see whether the two stakers are in the same challenge
* @param stakerAddress1 Address of the first staker
* @param stakerAddress2 Address of the second staker
* @return Address of the challenge that the two stakers are in
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
7825,
8287
]
} | 27,174 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | clearChallenge | function clearChallenge(address stakerAddress) internal {
Staker storage staker = _stakerMap[stakerAddress];
staker.currentChallenge = address(0);
}
| /**
* @notice Make the given staker as not being in a challenge
* @param stakerAddress Address of the staker to remove from a challenge
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
8447,
8619
]
} | 27,175 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | challengeStarted | function challengeStarted(
address staker1,
address staker2,
address challenge
) internal {
_stakerMap[staker1].currentChallenge = challenge;
_stakerMap[staker2].currentChallenge = challenge;
}
| /**
* @notice Mark both the given stakers as engaged in the challenge
* @param staker1 Address of the first staker
* @param staker2 Address of the second staker
* @param challenge Address of the challenge both stakers are now in
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
8882,
9127
]
} | 27,176 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | increaseStakeBy | function increaseStakeBy(address stakerAddress, uint256 amountAdded) internal {
Staker storage staker = _stakerMap[stakerAddress];
staker.amountStaked = staker.amountStaked.add(amountAdded);
}
| /**
* @notice Add to the stake of the given staker by the given amount
* @param stakerAddress Address of the staker to increase the stake of
* @param amountAdded Amount of stake to add to the staker
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
9355,
9571
]
} | 27,177 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | reduceStakeTo | function reduceStakeTo(address stakerAddress, uint256 target) internal returns (uint256) {
Staker storage staker = _stakerMap[stakerAddress];
uint256 current = staker.amountStaked;
require(target <= current, "TOO_LITTLE_STAKE");
uint256 amountWithdrawn = current.sub(target);
staker.amountStaked = ta... | /**
* @notice Reduce the stake of the given staker to the given target
* @param stakerAddress Address of the staker to reduce the stake of
* @param target Amount of stake to leave with the staker
* @return Amount of value released from the stake
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
9851,
10338
]
} | 27,178 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | turnIntoZombie | function turnIntoZombie(address stakerAddress) internal {
Staker storage staker = _stakerMap[stakerAddress];
_zombies.push(Zombie(stakerAddress, staker.latestStakedNode));
deleteStaker(stakerAddress);
}
| /**
* @notice Remove the given staker and turn them into a zombie
* @param stakerAddress Address of the staker to remove
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
10483,
10717
]
} | 27,179 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | zombieUpdateLatestStakedNode | function zombieUpdateLatestStakedNode(uint256 zombieNum, uint256 latest) internal {
_zombies[zombieNum].latestStakedNode = latest;
}
| /**
* @notice Update the latest staked node of the zombie at the given index
* @param zombieNum Index of the zombie to move
* @param latest New latest node the zombie is staked on
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
10926,
11074
]
} | 27,180 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | removeZombie | function removeZombie(uint256 zombieNum) internal {
_zombies[zombieNum] = _zombies[_zombies.length - 1];
_zombies.pop();
}
| /**
* @notice Remove the zombie at the given index
* @param zombieNum Index of the zombie to remove
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
11198,
11344
]
} | 27,181 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | withdrawStaker | function withdrawStaker(address stakerAddress) internal {
Staker storage staker = _stakerMap[stakerAddress];
_withdrawableFunds[stakerAddress] = _withdrawableFunds[stakerAddress].add(
staker.amountStaked
);
deleteStaker(stakerAddress);
}
| /**
* @notice Remove the given staker and return their stake
* @param stakerAddress Address of the staker withdrawing their stake
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
11498,
11787
]
} | 27,182 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | stakeOnNode | function stakeOnNode(
address stakerAddress,
uint256 nodeNum,
uint256 confirmPeriodBlocks
) internal {
Staker storage staker = _stakerMap[stakerAddress];
INode node = _nodes[nodeNum];
uint256 newStakerCount = node.addStaker(stakerAddress);
staker.latestStakedNode = nodeNum;
if (newStaker... | /**
* @notice Advance the given staker to the given node
* @param stakerAddress Address of the staker adding their stake
* @param nodeNum Index of the node to stake on
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
11984,
12504
]
} | 27,183 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | withdrawFunds | function withdrawFunds(address owner) internal returns (uint256) {
uint256 amount = _withdrawableFunds[owner];
_withdrawableFunds[owner] = 0;
return amount;
}
| /**
* @notice Clear the withdrawable funds for the given address
* @param owner Address of the account to remove funds from
* @return Amount of funds removed from account
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
12704,
12894
]
} | 27,184 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | increaseWithdrawableFunds | function increaseWithdrawableFunds(address owner, uint256 amount) internal {
_withdrawableFunds[owner] = _withdrawableFunds[owner].add(amount);
}
| /**
* @notice Increase the withdrawable funds for the given address
* @param owner Address of the account to add withdrawable funds to
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
13053,
13214
]
} | 27,185 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | deleteStaker | function deleteStaker(address stakerAddress) private {
Staker storage staker = _stakerMap[stakerAddress];
uint256 stakerIndex = staker.index;
_stakerList[stakerIndex] = _stakerList[_stakerList.length - 1];
_stakerMap[_stakerList[stakerIndex]].index = stakerIndex;
_stakerList.pop();
delete _stake... | /**
* @notice Remove the given staker
* @param stakerAddress Address of the staker to remove
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
13331,
13705
]
} | 27,186 | ||||
RollupEventBridge | contracts/rollup/RollupCore.sol | 0x5c7355e46d5486583a1cc211701e25004231d9dd | Solidity | RollupCore | contract RollupCore is IRollupCore {
using SafeMath for uint256;
struct Zombie {
address stakerAddress;
uint256 latestStakedNode;
}
struct Staker {
uint256 index;
uint256 latestStakedNode;
uint256 amountStaked;
// currentChallenge is 0 if staker is not i... | destroyNode | function destroyNode(uint256 nodeNum) internal {
_nodes[nodeNum].destroy();
_nodes[nodeNum] = INode(0);
}
| /**
* @notice Destroy the given node and clear out its address
* @param nodeNum Index of the node to remove
*/ | NatSpecMultiLine | v0.6.11+commit.5ef660b1 | {
"func_code_index": [
13837,
13966
]
} | 27,187 | ||||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | Controlled | contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
require(msg.sender == controller);
_;
}
//block for check//bool private initialed = false;
address public co... | //normal contract. already compiled as bin | LineComment | changeController | function changeController(address _newController) onlyController public {
controller = _newController;
}
| /// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
623,
746
]
} | 27,188 | |
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenController | contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
... | //abstract contract. used for interface | LineComment | proxyPayment | function proxyPayment(address _owner) payable public returns(bool);
| /// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
246,
318
]
} | 27,189 | |
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenController | contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
... | //abstract contract. used for interface | LineComment | onTransfer | function onTransfer(address _from, address _to, uint _amount) public returns(bool);
| /// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
664,
752
]
} | 27,190 | |
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenController | contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
... | //abstract contract. used for interface | LineComment | onApprove | function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
| /// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize... | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
1119,
1212
]
} | 27,191 | |
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | ERC20Token | contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contrac... | transfer | function transfer(address _to, uint256 _value) public returns (bool success);
| /// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
1094,
1176
]
} | 27,192 | |||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | ERC20Token | contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contrac... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
| /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
1499,
1600
]
} | 27,193 | |||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | ERC20Token | contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contrac... | approve | function approve(address _spender, uint256 _value) public returns (bool success);
| /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
1890,
1976
]
} | 27,194 | |||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenI | contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice ... | approveAndCall | function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
) public returns (bool success);
| /// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of... | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
822,
968
]
} | 27,195 | |||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenI | contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice ... | generateTokens | function generateTokens(address _owner, uint _amount) public returns (bool);
| /// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
1274,
1355
]
} | 27,196 | |||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenI | contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice ... | destroyTokens | function destroyTokens(address _owner, uint _amount) public returns (bool);
| /// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
1587,
1667
]
} | 27,197 | |||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenI | contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice ... | enableTransfers | function enableTransfers(bool _transfersEnabled) public;
| /// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
1826,
1887
]
} | 27,198 | |||
Token | Token.sol | 0x623afe103fb8d189b56311e4ce9956ec0989b412 | Solidity | TokenI | contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice ... | claimTokens | function claimTokens(address _token) public;
| /// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether. | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://d3da2119879769815ccccc2bbca0204e063d2f3864b656f7590e3767487a7cb9 | {
"func_code_index": [
2174,
2223
]
} | 27,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.