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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {sy... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _approve | function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amoun... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero a... | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
8462,
8813
]
} | 1,107 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {sy... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our... | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
| /**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* -... | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
9411,
9508
]
} | 1,108 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address owner) external view returns (uint256 balance);
| /**
* @dev Returns the number of tokens in ``owner``'s account.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
719,
798
]
} | 1,109 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | 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.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
944,
1021
]
} | 1,110 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId) 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.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1733,
1816
]
} | 1,111 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | 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.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2342,
2421
]
} | 1,112 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | approve | function approve(address to, uint256 tokenId) external;
| /**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token... | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2894,
2954
]
} | 1,113 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | getApproved | function getApproved(uint256 tokenId) external view returns (address operator);
| /**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3108,
3192
]
} | 1,114 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | setApprovalForAll | function setApprovalForAll(address operator, bool _approved) external;
| /**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3519,
3594
]
} | 1,115 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | isApprovedForAll | function isApprovedForAll(address owner, address operator) external view returns (bool);
| /**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3745,
3838
]
} | 1,116 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC721 | interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
... | /**
* @dev Required interface of an ERC721 compliant contract.
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
| /**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {appro... | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
4427,
4531
]
} | 1,117 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC1155 | interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to... | /**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account, uint256 id) external view returns (uint256);
| /**
* @dev Returns the amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1411,
1496
]
} | 1,118 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC1155 | interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to... | /**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/ | NatSpecMultiLine | balanceOfBatch | function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);
| /**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1699,
1822
]
} | 1,119 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC1155 | interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to... | /**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/ | NatSpecMultiLine | setApprovalForAll | function setApprovalForAll(address operator, bool approved) external;
| /**
* @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
*
* Emits an {ApprovalForAll} event.
*
* Requirements:
*
* - `operator` cannot be the caller.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2087,
2161
]
} | 1,120 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC1155 | interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to... | /**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/ | NatSpecMultiLine | isApprovedForAll | function isApprovedForAll(address account, address operator) external view returns (bool);
| /**
* @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
*
* See {setApprovalForAll}.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2309,
2404
]
} | 1,121 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC1155 | interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to... | /**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
| /**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must h... | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2984,
3099
]
} | 1,122 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | IERC1155 | interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to... | /**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/ | NatSpecMultiLine | safeBatchTransferFrom | function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external;
| /**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and ret... | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3508,
3652
]
} | 1,123 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ECDSA | library ECDSA {
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the ... | /**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/ | NatSpecMultiLine | recover | function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
... | /**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half ord... | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
811,
1577
]
} | 1,124 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ECDSA | library ECDSA {
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the ... | /**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/ | NatSpecMultiLine | recover | function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), de... | /**
* @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`,
* `r` and `s` signature fields separately.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1726,
3160
]
} | 1,125 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ECDSA | library ECDSA {
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the ... | /**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/ | NatSpecMultiLine | toEthSignedMessageHash | function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
| /**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* replicates the behavior of the
* https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
* JSON-RPC method.
*
* See {recover}.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3429,
3703
]
} | 1,126 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | AccessControl | contract AccessControl {
// The addresses that can co-sign transactions on the wallet
mapping(address => bool) signers;
// Frozen account that cant move funds
mapping (address => bool) private _frozen;
event Frozen(address target);
event Unfrozen(address target);
/**
* Set ... | /**
* Access control holds contract signers (board members) and frozen accounts.
* Have utility modifiers for method safe access.
*/ | NatSpecMultiLine | isSigner | function isSigner(address _addr) public view returns (bool) {
return signers[_addr];
}
| /**
* @dev Checks if provided address has signer permissions.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1385,
1490
]
} | 1,127 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | AccessControl | contract AccessControl {
// The addresses that can co-sign transactions on the wallet
mapping(address => bool) signers;
// Frozen account that cant move funds
mapping (address => bool) private _frozen;
event Frozen(address target);
event Unfrozen(address target);
/**
* Set ... | /**
* Access control holds contract signers (board members) and frozen accounts.
* Have utility modifiers for method safe access.
*/ | NatSpecMultiLine | isFrozen | function isFrozen(address target) public view returns (bool) {
return _frozen[target];
}
| /**
* @dev Returns true if the target account is frozen.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1570,
1677
]
} | 1,128 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | AccessControl | contract AccessControl {
// The addresses that can co-sign transactions on the wallet
mapping(address => bool) signers;
// Frozen account that cant move funds
mapping (address => bool) private _frozen;
event Frozen(address target);
event Unfrozen(address target);
/**
* Set ... | /**
* Access control holds contract signers (board members) and frozen accounts.
* Have utility modifiers for method safe access.
*/ | NatSpecMultiLine | _unfreeze | function _unfreeze(address target) internal {
require(_frozen[target], "AccessControl: Target account is not frozen");
delete _frozen[target];
emit Unfrozen(target);
}
| /**
* @dev Mark target account as unfrozen.
* Can be called even if the contract doesn't allow to freeze accounts.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2029,
2233
]
} | 1,129 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | AccessControl | contract AccessControl {
// The addresses that can co-sign transactions on the wallet
mapping(address => bool) signers;
// Frozen account that cant move funds
mapping (address => bool) private _frozen;
event Frozen(address target);
event Unfrozen(address target);
/**
* Set ... | /**
* Access control holds contract signers (board members) and frozen accounts.
* Have utility modifiers for method safe access.
*/ | NatSpecMultiLine | withdrawERC20 | function withdrawERC20(IERC20 _tokenContract) external onlySigner {
uint256 balance = _tokenContract.balanceOf(address(this));
_tokenContract.transfer(msg.sender, balance);
}
| /**
* @dev Allow to withdraw ERC20 tokens from contract itself
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2319,
2521
]
} | 1,130 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | AccessControl | contract AccessControl {
// The addresses that can co-sign transactions on the wallet
mapping(address => bool) signers;
// Frozen account that cant move funds
mapping (address => bool) private _frozen;
event Frozen(address target);
event Unfrozen(address target);
/**
* Set ... | /**
* Access control holds contract signers (board members) and frozen accounts.
* Have utility modifiers for method safe access.
*/ | NatSpecMultiLine | approveERC721 | function approveERC721(IERC721 _tokenContract) external onlySigner {
_tokenContract.setApprovalForAll(msg.sender, true);
}
| /**
* @dev Allow to withdraw ERC721 tokens from contract itself
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2608,
2749
]
} | 1,131 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | AccessControl | contract AccessControl {
// The addresses that can co-sign transactions on the wallet
mapping(address => bool) signers;
// Frozen account that cant move funds
mapping (address => bool) private _frozen;
event Frozen(address target);
event Unfrozen(address target);
/**
* Set ... | /**
* Access control holds contract signers (board members) and frozen accounts.
* Have utility modifiers for method safe access.
*/ | NatSpecMultiLine | approveERC1155 | function approveERC1155(IERC1155 _tokenContract) external onlySigner {
_tokenContract.setApprovalForAll(msg.sender, true);
}
| /**
* @dev Allow to withdraw ERC1155 tokens from contract itself
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2837,
2980
]
} | 1,132 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | AccessControl | contract AccessControl {
// The addresses that can co-sign transactions on the wallet
mapping(address => bool) signers;
// Frozen account that cant move funds
mapping (address => bool) private _frozen;
event Frozen(address target);
event Unfrozen(address target);
/**
* Set ... | /**
* Access control holds contract signers (board members) and frozen accounts.
* Have utility modifiers for method safe access.
*/ | NatSpecMultiLine | withdrawEth | function withdrawEth(address payable _receiver) external onlySigner {
if (address(this).balance > 0) {
_receiver.transfer(address(this).balance);
}
}
| /**
* @dev Allow to withdraw ETH from contract itself
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3057,
3247
]
} | 1,133 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ERC20Burnable | abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Destroys `amount` tokens from `account`... | /**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burn | function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
| /**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
161,
257
]
} | 1,134 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ERC20Burnable | abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Destroys `amount` tokens from `account`... | /**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burnFrom | function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "BCUG: burn amount exceeds allowance");
_approve(account, _msgSender(), currentAllowance - amount);
_burn(account, amount);
}
| /**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
571,
907
]
} | 1,135 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ERC20Capped | abstract contract ERC20Capped is ERC20 {
uint256 private _cap;
/**
* @dev Sets the value of the `cap`. This value is immutable, it can only be
* set once during construction.
*/
constructor (uint256 cap_) {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
... | /**
* @dev Extension of {ERC20} that adds a cap to the supply of tokens.
*/ | NatSpecMultiLine | cap | function cap() public view virtual returns (uint256) {
return _cap;
}
| /**
* @dev Returns the cap on the token's total supply.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
403,
491
]
} | 1,136 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | ERC20Capped | abstract contract ERC20Capped is ERC20 {
uint256 private _cap;
/**
* @dev Sets the value of the `cap`. This value is immutable, it can only be
* set once during construction.
*/
constructor (uint256 cap_) {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
... | /**
* @dev Extension of {ERC20} that adds a cap to the supply of tokens.
*/ | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
}
}
| /**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - minted tokens must not cause the total supply to go over the cap.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
673,
994
]
} | 1,137 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | Pausable | abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
... | /**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your co... | NatSpecMultiLine | paused | function paused() public view virtual returns (bool) {
return _paused;
}
| /**
* @dev Returns true if the contract is paused, and false otherwise.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
531,
622
]
} | 1,138 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | Pausable | abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
... | /**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your co... | NatSpecMultiLine | _pause | function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
| /**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1331,
1454
]
} | 1,139 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | Pausable | abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
... | /**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your co... | NatSpecMultiLine | _unpause | function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
| /**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1590,
1715
]
} | 1,140 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | mint | function mint(address target, uint256 amount, bytes[] memory signatures) external onlySigner {
bytes32 operationHash = getOperationHash(MINT_TYPEHASH, target, amount).toEthSignedMessageHash();
_verifySignatures(signatures, operationHash);
_mint(target, amount);
}
| /**
* @dev Mint some tokens to target account
* MultiSig check is used - verifies that contract signers approve minting.
* During minting applied check for the max token cap.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1986,
2286
]
} | 1,141 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | mintBulk | function mintBulk(address[] calldata target, uint256[] calldata amount, bytes[] memory signatures) external onlySigner {
require(target.length > 1, "GovernanceToken: cannot perform bulk with single target");
require(target.length == amount.length, "GovernanceToken: target.length != amount.length");
byt... | /**
* @dev Bulk operation to mint tokens to target accounts. There is a check for the cap inside.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2407,
3022
]
} | 1,142 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | freeze | function freeze(address target, bytes[] memory signatures) external onlySigner {
bytes32 operationHash = getOperationHash(FREEZE_TYPEHASH, target, 1).toEthSignedMessageHash();
_verifySignatures(signatures, operationHash);
_freeze(target);
}
| /**
* @dev Mark target account as frozen. Frozen accounts can't perform transfers.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3126,
3405
]
} | 1,143 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | unfreeze | function unfreeze(address target, bytes[] memory signatures) external onlySigner {
bytes32 operationHash = getOperationHash(FREEZE_TYPEHASH, target, 1).toEthSignedMessageHash();
_verifySignatures(signatures, operationHash);
_unfreeze(target);
}
| /**
* @dev Mark target account as unfrozen.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3472,
3755
]
} | 1,144 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | burnFrozenTokens | function burnFrozenTokens(address target, bytes[] memory signatures) external onlySigner {
require(isFrozen(target), "GovernanceToken: target account is not frozen");
bytes32 operationHash = getOperationHash(BURN_FROZEN_TYPEHASH, target, 1).toEthSignedMessageHash();
_verifySignatures(signatures, operat... | /**
* @dev Burn tokens on frozen account.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
4794,
5192
]
} | 1,145 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | freezeAndBurnTokens | function freezeAndBurnTokens(address target, bytes[] memory signatures) external onlySigner {
bytes32 operationHash = getOperationHash(FREEZE_AND_BURN_TYPEHASH, target, 1).toEthSignedMessageHash();
_verifySignatures(signatures, operationHash);
_freeze(target);
_burn(target, balanceOf(target));
}
... | /**
* @dev Freeze and burn tokens in a single transaction.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
5274,
5618
]
} | 1,146 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | pause | function pause(bytes[] memory signatures) external onlySigner {
bytes32 operationHash = getOperationHash(PAUSE_TYPEHASH, msg.sender, 1).toEthSignedMessageHash();
_verifySignatures(signatures, operationHash);
_pause();
}
| /**
* @dev Triggers stopped state.
* - The contract must not be paused and pause should be allowed.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
5747,
6005
]
} | 1,147 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | unpause | function unpause(bytes[] memory signatures) external onlySigner {
bytes32 operationHash = getOperationHash(PAUSE_TYPEHASH, msg.sender, 1).toEthSignedMessageHash();
_verifySignatures(signatures, operationHash);
_unpause();
}
| /**
* @dev Returns to normal state.
* - The contract must be paused.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
6103,
6365
]
} | 1,148 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | getOperationHash | function getOperationHash(bytes32 typehash, address target, uint256 value) public view returns (bytes32) {
return keccak256(abi.encodePacked(address(this), typehash, target, value, nonce));
}
| /**
* @dev Get operation hash for multisig operation
* Nonce used to ensure that signature used only once.
* Use unique typehash for each operation.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
6545,
6755
]
} | 1,149 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20Capped, ERC20) {
super._beforeTokenTransfer(from, to, amount);
require(to != address(this), "GovernanceToken: can't transfer to token contract self");
require(!paused(), "GovernanceToken: token transf... | /**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - do not allow the transfer of funds to the token contract itself. Usually such a call is a mistake.
* - do not allow transfers when contract is paused.
* - only allow to burn frozen tokens.
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
7072,
7537
]
} | 1,150 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | GovernanceToken | abstract contract GovernanceToken is ERC20Capped, ERC20Burnable, IFungibleToken, AccessControl, Pausable {
using ECDSA for bytes32;
// keccak256("mint(address target, uint256 amount, bytes[] signatures)")
bytes32 constant MINT_TYPEHASH = 0xdaef0006354e6aca5b14786fab16e27867b1ac002611e2fa58e0aa486080141... | /**
* Governance Token contract includes multisig protected actions.
* It includes:
* - minting methods
* - freeze methods
* - pause methods
*
* For each call must be provided valid signatures from contract signers (defined in AccessControl)
* and the transaction itself must be sent from the signer addr... | NatSpecMultiLine | _verifySignatures | function _verifySignatures(bytes[] memory signatures, bytes32 operationHash) internal {
require(signatures.length >= 2, "AccessControl: not enough confirmations");
address[] memory recovered = new address[](signatures.length + 1);
recovered[0] = msg.sender;
emit SignedBy(msg.sender);
for (u... | /**
* @dev Verify provided signatures according to the operation hash
* Ensure that each signature belongs to contract known signer and is unique
*/ | NatSpecMultiLine | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
7712,
8626
]
} | 1,151 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | BCUG | contract BCUG is GovernanceToken {
constructor (address[] memory allowedSigners) GovernanceToken("Blockchain Cuties Universe Governance Token", "BCUG", 10000000 ether, allowedSigners) {}
// @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract.
function withdra... | /**
* @title Blockchain Cuties Universe fungible token base contract
* @dev Implementation of the {IERC20}, {IERC827} and {IERC223} interfaces.
* Token holders can burn their tokens.
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavi... | NatSpecMultiLine | withdrawTokenFromBalance | function withdrawTokenFromBalance(IERC20 _tokenContract, address _withdrawToAddress) external onlySigner {
uint256 balance = _tokenContract.balanceOf(address(this));
_tokenContract.transfer(_withdrawToAddress, balance);
}
| // @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract. | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
300,
549
]
} | 1,152 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | BCUG | contract BCUG is GovernanceToken {
constructor (address[] memory allowedSigners) GovernanceToken("Blockchain Cuties Universe Governance Token", "BCUG", 10000000 ether, allowedSigners) {}
// @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract.
function withdra... | /**
* @title Blockchain Cuties Universe fungible token base contract
* @dev Implementation of the {IERC20}, {IERC827} and {IERC223} interfaces.
* Token holders can burn their tokens.
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavi... | NatSpecMultiLine | approveAndCall | function approveAndCall(address spender, uint tokens, bytes calldata data) external override returns (bool success) {
_approve(msg.sender, spender, tokens);
TokenRecipientInterface(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
| // ---------------------------- ERC827 approveAndCall ----------------------------
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...... | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1004,
1303
]
} | 1,153 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | BCUG | contract BCUG is GovernanceToken {
constructor (address[] memory allowedSigners) GovernanceToken("Blockchain Cuties Universe Governance Token", "BCUG", 10000000 ether, allowedSigners) {}
// @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract.
function withdra... | /**
* @title Blockchain Cuties Universe fungible token base contract
* @dev Implementation of the {IERC20}, {IERC827} and {IERC223} interfaces.
* Token holders can burn their tokens.
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavi... | NatSpecMultiLine | transferBulk | function transferBulk(address[] calldata to, uint[] calldata tokens) external override {
require(to.length == tokens.length, "transferBulk: to.length != tokens.length");
for (uint i = 0; i < to.length; i++)
{
_transfer(msg.sender, to[i], tokens[i]);
}
}
| // ---------------------------- ERC20 Bulk Operations ---------------------------- | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
1396,
1708
]
} | 1,154 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | BCUG | contract BCUG is GovernanceToken {
constructor (address[] memory allowedSigners) GovernanceToken("Blockchain Cuties Universe Governance Token", "BCUG", 10000000 ether, allowedSigners) {}
// @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract.
function withdra... | /**
* @title Blockchain Cuties Universe fungible token base contract
* @dev Implementation of the {IERC20}, {IERC827} and {IERC223} interfaces.
* Token holders can burn their tokens.
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavi... | NatSpecMultiLine | transfer | function transfer(address _to, uint _value, bytes calldata _data) external override returns (bool success) {
return transferWithData(_to, _value, _data);
}
| // Function that is called when a user or another contract wants to transfer funds . | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2303,
2477
]
} | 1,155 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | BCUG | contract BCUG is GovernanceToken {
constructor (address[] memory allowedSigners) GovernanceToken("Blockchain Cuties Universe Governance Token", "BCUG", 10000000 ether, allowedSigners) {}
// @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract.
function withdra... | /**
* @title Blockchain Cuties Universe fungible token base contract
* @dev Implementation of the {IERC20}, {IERC827} and {IERC223} interfaces.
* Token holders can burn their tokens.
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavi... | NatSpecMultiLine | transferToContract | function transferToContract(address _to, uint _value, bytes calldata _data) public returns (bool success) {
_transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
TokenFallback receiver = TokenFallback(_to);
receiver.tokenFallback(msg.sender, _value, _data);
return t... | // function that is called when transaction target is a contract | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
2860,
3216
]
} | 1,156 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | BCUG | contract BCUG is GovernanceToken {
constructor (address[] memory allowedSigners) GovernanceToken("Blockchain Cuties Universe Governance Token", "BCUG", 10000000 ether, allowedSigners) {}
// @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract.
function withdra... | /**
* @title Blockchain Cuties Universe fungible token base contract
* @dev Implementation of the {IERC20}, {IERC827} and {IERC223} interfaces.
* Token holders can burn their tokens.
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavi... | NatSpecMultiLine | _isContract | function _isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return length > 0;
}
| // assemble the given address bytecode. If bytecode exists then the _addr is a contract. | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3313,
3605
]
} | 1,157 |
BCUG | BCUG.sol | 0x14da7b27b2e0fedefe0a664118b0c9bc68e2e9af | Solidity | BCUG | contract BCUG is GovernanceToken {
constructor (address[] memory allowedSigners) GovernanceToken("Blockchain Cuties Universe Governance Token", "BCUG", 10000000 ether, allowedSigners) {}
// @dev Transfers to _withdrawToAddress all tokens controlled by
// contract _tokenContract.
function withdra... | /**
* @title Blockchain Cuties Universe fungible token base contract
* @dev Implementation of the {IERC20}, {IERC827} and {IERC223} interfaces.
* Token holders can burn their tokens.
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavi... | NatSpecMultiLine | transferToAddress | function transferToAddress(address _to, uint tokens, bytes calldata _data) public returns (bool success) {
_transfer(msg.sender, _to, tokens);
emit Transfer(msg.sender, _to, tokens, _data);
return true;
}
| // function that is called when transaction target is an address | LineComment | v0.8.1+commit.df193b15 | MIT | ipfs://b5a9bf50d6ab20fb6187e0977c4859ef104592e8af65af586f892117edccd45a | {
"func_code_index": [
3678,
3919
]
} | 1,158 |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | initialize | function initialize(
address _archToken,
address _vestingContract
) public initializer {
__ReentrancyGuard_init_unchained();
AppStorage storage app = VotingPowerStorage.appStorage();
app.archToken = IArchToken(_archToken);
app.vesting = IVesting(_vestingContract);
}
| /**
* @notice Initialize VotingPower contract
* @dev Should be called via VotingPowerPrism before calling anything else
* @param _archToken address of ARCH token
* @param _vestingContract address of Vesting contract
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
965,
1291
]
} | 1,159 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | archToken | function archToken() public view returns (address) {
AppStorage storage app = VotingPowerStorage.appStorage();
return address(app.archToken);
}
| /**
* @notice Address of ARCH token
* @return Address of ARCH token
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
1383,
1550
]
} | 1,160 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | vestingContract | function vestingContract() public view returns (address) {
AppStorage storage app = VotingPowerStorage.appStorage();
return address(app.vesting);
}
| /**
* @notice Address of vesting contract
* @return Address of vesting contract
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
1654,
1825
]
} | 1,161 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | stakeWithPermit | function stakeWithPermit(uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
require(amount > 0, "VP::stakeWithPermit: cannot stake 0");
AppStorage storage app = VotingPowerStorage.appStorage();
require(app.archToken.balanceOf(msg.sender) >= amount, "VP::stakeWithPermit:... | /**
* @notice Stake ARCH tokens using offchain approvals to unlock voting power
* @param amount The amount to stake
* @param deadline The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
2179,
2696
]
} | 1,162 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | stake | function stake(uint256 amount) external nonReentrant {
AppStorage storage app = VotingPowerStorage.appStorage();
require(amount > 0, "VP::stake: cannot stake 0");
require(app.archToken.balanceOf(msg.sender) >= amount, "VP::stake: not enough tokens");
require(app.archToken.allowance(msg.sender, address(t... | /**
* @notice Stake ARCH tokens to unlock voting power for `msg.sender`
* @param amount The amount to stake
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
2828,
3309
]
} | 1,163 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | addVotingPowerForVestingTokens | function addVotingPowerForVestingTokens(address account, uint256 amount) external nonReentrant {
AppStorage storage app = VotingPowerStorage.appStorage();
require(amount > 0, "VP::addVPforVT: cannot add 0 voting power");
require(msg.sender == address(app.vesting), "VP::addVPforVT: only vesting contract");
... | /**
* @notice Count vesting ARCH tokens toward voting power for `account`
* @param account The recipient of voting power
* @param amount The amount of voting power to add
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
3509,
3897
]
} | 1,164 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | removeVotingPowerForClaimedTokens | function removeVotingPowerForClaimedTokens(address account, uint256 amount) external nonReentrant {
AppStorage storage app = VotingPowerStorage.appStorage();
require(amount > 0, "VP::removeVPforVT: cannot remove 0 voting power");
require(msg.sender == address(app.vesting), "VP::removeVPforVT: only vesting c... | /**
* @notice Remove claimed vesting ARCH tokens from voting power for `account`
* @param account The account with voting power
* @param amount The amount of voting power to remove
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
4107,
4507
]
} | 1,165 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | withdraw | function withdraw(uint256 amount) external nonReentrant {
require(amount > 0, "VP::withdraw: cannot withdraw 0");
AppStorage storage app = VotingPowerStorage.appStorage();
_withdraw(msg.sender, address(app.archToken), amount, amount);
}
| /**
* @notice Withdraw staked ARCH tokens, removing voting power for `msg.sender`
* @param amount The amount to withdraw
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
4652,
4920
]
} | 1,166 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | getARCHAmountStaked | function getARCHAmountStaked(address staker) public view returns (uint256) {
return getARCHStake(staker).amount;
}
| /**
* @notice Get total amount of ARCH tokens staked in contract by `staker`
* @param staker The user with staked ARCH
* @return total ARCH amount staked
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
5103,
5233
]
} | 1,167 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | getAmountStaked | function getAmountStaked(address staker, address stakedToken) public view returns (uint256) {
return getStake(staker, stakedToken).amount;
}
| /**
* @notice Get total amount of tokens staked in contract by `staker`
* @param staker The user with staked tokens
* @param stakedToken The staked token
* @return total amount staked
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
5451,
5607
]
} | 1,168 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | getARCHStake | function getARCHStake(address staker) public view returns (Stake memory) {
AppStorage storage app = VotingPowerStorage.appStorage();
return getStake(staker, address(app.archToken));
}
| /**
* @notice Get staked amount and voting power from ARCH tokens staked in contract by `staker`
* @param staker The user with staked ARCH
* @return total ARCH staked
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
5803,
6010
]
} | 1,169 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | getStake | function getStake(address staker, address stakedToken) public view returns (Stake memory) {
StakeStorage storage ss = VotingPowerStorage.stakeStorage();
return ss.stakes[staker][stakedToken];
}
| /**
* @notice Get total staked amount and voting power from `stakedToken` staked in contract by `staker`
* @param staker The user with staked tokens
* @param stakedToken The staked token
* @return total staked
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
6254,
6471
]
} | 1,170 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view returns (uint256) {
CheckpointStorage storage cs = VotingPowerStorage.checkpointStorage();
uint32 nCheckpoints = cs.numCheckpoints[account];
return nCheckpoints > 0 ? cs.checkpoints[account][nCheckpoints - 1].votes : 0;
}
| /**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
6661,
6962
]
} | 1,171 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | balanceOfAt | function balanceOfAt(address account, uint256 blockNumber) public view returns (uint256) {
require(blockNumber < block.number, "VP::balanceOfAt: not yet determined");
CheckpointStorage storage cs = VotingPowerStorage.checkpointStorage();
uint32 nCheckpoints = cs.numCheckpoints[account];
if (nCh... | /**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @r... | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
7380,
8673
]
} | 1,172 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | _stake | function _stake(address voter, address token, uint256 tokenAmount, uint256 votingPower) internal {
IERC20(token).safeTransferFrom(voter, address(this), tokenAmount);
StakeStorage storage ss = VotingPowerStorage.stakeStorage();
ss.stakes[voter][token].amount = ss.stakes[voter][token].amount.add(tokenAmount)... | /**
* @notice Internal implementation of stake
* @param voter The user that is staking tokens
* @param token The token to stake
* @param tokenAmount The amount of token to stake
* @param votingPower The amount of voting power stake translates into
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
8960,
9516
]
} | 1,173 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | _withdraw | function _withdraw(address voter, address token, uint256 tokenAmount, uint256 votingPower) internal {
StakeStorage storage ss = VotingPowerStorage.stakeStorage();
require(ss.stakes[voter][token].amount >= tokenAmount, "VP::_withdraw: not enough tokens staked");
require(ss.stakes[voter][token].votingPower >=... | /**
* @notice Internal implementation of withdraw
* @param voter The user with tokens staked
* @param token The token that is staked
* @param tokenAmount The amount of token to withdraw
* @param votingPower The amount of voting power stake translates into
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
9811,
10588
]
} | 1,174 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | _increaseVotingPower | function _increaseVotingPower(address voter, uint256 amount) internal {
CheckpointStorage storage cs = VotingPowerStorage.checkpointStorage();
uint32 checkpointNum = cs.numCheckpoints[voter];
uint256 votingPowerOld = checkpointNum > 0 ? cs.checkpoints[voter][checkpointNum - 1].votes : 0;
uint256 votingP... | /**
* @notice Increase voting power of voter
* @param voter The voter whose voting power is increasing
* @param amount The amount of voting power to increase by
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
10779,
11242
]
} | 1,175 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | _decreaseVotingPower | function _decreaseVotingPower(address voter, uint256 amount) internal {
CheckpointStorage storage cs = VotingPowerStorage.checkpointStorage();
uint32 checkpointNum = cs.numCheckpoints[voter];
uint256 votingPowerOld = checkpointNum > 0 ? cs.checkpoints[voter][checkpointNum - 1].votes : 0;
uint256 votingP... | /**
* @notice Decrease voting power of voter
* @param voter The voter whose voting power is decreasing
* @param amount The amount of voting power to decrease by
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
11433,
11896
]
} | 1,176 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | _writeCheckpoint | function _writeCheckpoint(address voter, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes) internal {
uint32 blockNumber = _safe32(block.number, "VP::_writeCheckpoint: block number exceeds 32 bits");
CheckpointStorage storage cs = VotingPowerStorage.checkpointStorage();
if (nCheckpoints > 0 && cs.checkpoi... | /**
* @notice Create checkpoint of voting power for voter at current block number
* @param voter The voter whose voting power is changing
* @param nCheckpoints The current checkpoint number for voter
* @param oldVotes The previous voting power of this voter
* @param newVotes The new voting power of this voter
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
12246,
12932
]
} | 1,177 | |
VotingPower | contracts/VotingPower.sol | 0xd07d77eab98f32f672de1f5b6a6aa824582e74cd | Solidity | VotingPower | contract VotingPower is PrismProxyImplementation, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice An event that's emitted when a user's staked balance increases
event Staked(address indexed user, address indexed token, uint256 indexed amount, uint256 vot... | /**
* @title VotingPower
* @dev Implementation contract for voting power prism proxy
* Calls should not be made directly to this contract, instead make calls to the VotingPowerPrism proxy contract
* The exception to this is the `become` function specified in PrismProxyImplementation
* This function is called once ... | NatSpecMultiLine | _safe32 | function _safe32(uint256 n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
| /**
* @notice Converts uint256 to uint32 safely
* @param n Number
* @param errorMessage Error message to use if number cannot be converted
* @return uint32 number
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | {
"func_code_index": [
13129,
13295
]
} | 1,178 | |
PBCToken | PBCToken.sol | 0x18377e3bad04f08e887540faa15a9850bdfdc66c | Solidity | ERC20Basic | contract ERC20Basic {
// events
event Transfer(address indexed from, address indexed to, uint256 value);
// public functions
function totalSupply() public view returns (uint256);
function balanceOf(address addr) public view returns (uint256);
function transfer(address to, uint256 value) public retur... | totalSupply | function totalSupply() public view returns (uint256);
| // public functions | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://e80b1b77d08c1490df6158cf0210faf696e94fd060102ebcafd41c9dd8fdbc69 | {
"func_code_index": [
137,
193
]
} | 1,179 | ||
PBCToken | PBCToken.sol | 0x18377e3bad04f08e887540faa15a9850bdfdc66c | Solidity | ERC20 | contract ERC20 is ERC20Basic {
// events
event Approval(address indexed owner, address indexed agent, uint256 value);
// public functions
function allowance(address owner, address agent) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);... | allowance | function allowance(address owner, address agent) public view returns (uint256);
| // public functions | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://e80b1b77d08c1490df6158cf0210faf696e94fd060102ebcafd41c9dd8fdbc69 | {
"func_code_index": [
150,
232
]
} | 1,180 | ||
PBCToken | PBCToken.sol | 0x18377e3bad04f08e887540faa15a9850bdfdc66c | Solidity | Freezeable | contract Freezeable is Freezer {
// public variables
// internal variables
mapping(address => bool) _freezeList;
// events
event Freezed(address indexed freezedAddr);
event UnFreezed(address indexed unfreezedAddr);
// public functions
function freeze(address addr) public onlyFreezer return... | freeze | function freeze(address addr) public onlyFreezer returns (bool) {
require(true != _freezeList[addr]);
_freezeList[addr] = true;
emit Freezed(addr);
return true;
}
| // public functions | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://e80b1b77d08c1490df6158cf0210faf696e94fd060102ebcafd41c9dd8fdbc69 | {
"func_code_index": [
263,
455
]
} | 1,181 | ||
PBCToken | PBCToken.sol | 0x18377e3bad04f08e887540faa15a9850bdfdc66c | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
// public variables
string public name;
string public symbol;
uint8 public decimals = 18;
// internal variables
uint256 _totalSupply;
mapping(address => uint256) _balances;
// events
// public functions
function tot... | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| // events
// public functions | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://e80b1b77d08c1490df6158cf0210faf696e94fd060102ebcafd41c9dd8fdbc69 | {
"func_code_index": [
306,
394
]
} | 1,182 | ||
PBCToken | PBCToken.sol | 0x18377e3bad04f08e887540faa15a9850bdfdc66c | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
// public variables
// internal variables
mapping (address => mapping (address => uint256)) _allowances;
// events
// public functions
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(to != address(0... | transferFrom | function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(to != address(0));
require(value <= _balances[from]);
require(value <= _allowances[from][msg.sender]);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
_allowances[fr... | // events
// public functions | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://e80b1b77d08c1490df6158cf0210faf696e94fd060102ebcafd41c9dd8fdbc69 | {
"func_code_index": [
203,
657
]
} | 1,183 | ||
PBCToken | PBCToken.sol | 0x18377e3bad04f08e887540faa15a9850bdfdc66c | Solidity | FreezeableToken | contract FreezeableToken is StandardToken, Freezeable, Ownable {
// public variables
// internal variables
// events
// public functions
function transfer(address to, uint256 value) public whenNotFreezed returns (bool) {
require(true != _freezeList[to]);
return super.transfer(to, value);
... | transfer | function transfer(address to, uint256 value) public whenNotFreezed returns (bool) {
require(true != _freezeList[to]);
return super.transfer(to, value);
}
| // public variables
// internal variables
// events
// public functions | LineComment | v0.4.24+commit.e67f0147 | None | bzzr://e80b1b77d08c1490df6158cf0210faf696e94fd060102ebcafd41c9dd8fdbc69 | {
"func_code_index": [
156,
325
]
} | 1,184 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | withdraw | function withdraw() external onlyOwner {
address payable payableOwner = payable(owner());
payableOwner.transfer(address(this).balance);
}
| /**
* Payout
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
2399,
2548
]
} | 1,185 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | paused | function paused() external view returns (bool) {
return _paused;
}
| /**
* Pausing
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
2821,
2895
]
} | 1,186 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | getOracle | function getOracle() external view returns (address, bytes32, uint256) {
return (oracle, jobId, fee);
}
| /**
* Updating Oracle
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
3008,
3119
]
} | 1,187 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | getGenerativeMinted | function getGenerativeMinted() external view returns (uint256) {
return generativeMinted.current();
}
| /**
* Methods for Web3
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
3312,
3421
]
} | 1,188 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | mintTrunk | function mintTrunk(uint256 randomSeed, bool isBasic) external payable returns (uint256 tokenId) {
// Enforce tiered fees.
require(msg.value >= getBaseFeeTier());
require(msg.value >= getFeeTier());
// In pause, prevent "free" mints.
if (_paused) {
require(msg.value >= (0.05 ether));
}
// Update mint... | /**
* Generative minting
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
3669,
5122
]
} | 1,189 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | mintGenesisTrunk | function mintGenesisTrunk(uint256 numberToMint) external payable returns (uint256[] memory tokenIds) {
// Minting constraints.
require(numberToMint >= 1);
require(numberToMint <= 20);
require(numberToMint <= (genesisSupply - genesisMinted.current()));
// Ensure we collect enough eth!
require(msg.value >= (... | /**
* Genesis minting
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
6896,
7497
]
} | 1,190 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | fetchGenesisSeedFromVRF | function fetchGenesisSeedFromVRF() external onlyOwner {
getRandomNumber();
}
| // Required to be called before first mint to populate genesisRandomSeed. | LineComment | v0.6.6+commit.6c089d02 | {
"func_code_index": [
8190,
8274
]
} | 1,191 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | getRandomGenesisTrunk | function getRandomGenesisTrunk(uint256 index) private view returns (uint256) {
return (((index * genesisPrime) + genesisRandomSeed) % genesisSupply) + 1;
}
| // "Shuffles" our list, from random seed, without using much storage, starting at 1.
// This works because (a x + b) modulo n visits all integers in 0..<n exactly once
// as x iterates through the integers in 0..<n, so long as a is coprime with n. | LineComment | v0.6.6+commit.6c089d02 | {
"func_code_index": [
8530,
8693
]
} | 1,192 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | setBaseURI | function setBaseURI(string calldata baseURI_) external onlyOwner {
// Allows us to update the baseURI after deploy, so we can move to IPFS if we choose to.
_setBaseURI(baseURI_);
}
| // Updates | LineComment | v0.6.6+commit.6c089d02 | {
"func_code_index": [
8708,
8900
]
} | 1,193 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | remoteMint | function remoteMint(uint256 randomSeed, uint256 tokenId) private returns (bytes32 requestId) {
// Make the Chainlink request.
Chainlink.Request memory request = buildChainlinkRequest(jobId, address(this), this.fulfill.selector);
string memory url = string(
abi.encodePacked(
"https://service.cryptotrunks... | // Regular | LineComment | v0.6.6+commit.6c089d02 | {
"func_code_index": [
8951,
9559
]
} | 1,194 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | remoteMintTwenty | function remoteMintTwenty(uint256 tokenId) private returns (bytes32 requestId) {
// Make the Chainlink request.
Chainlink.Request memory request = buildChainlinkRequest(jobId, address(this), this.fulfillTwenty.selector);
string memory url = string(
abi.encodePacked(
"https://service.cryptotrunks.co/mint... | // Minting 20 ("Gamble") | LineComment | v0.6.6+commit.6c089d02 | {
"func_code_index": [
10649,
11215
]
} | 1,195 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | getRandomNumber | function getRandomNumber() private returns (bytes32 requestId) {
// Only permit if this has never been run.
require(genesisRandomSeed == 0);
return requestRandomness(keyHash, vrfFee, block.number);
}
| /**
* Chainlink VRF
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
11806,
12022
]
} | 1,196 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | toString | function toString(address account) private pure returns (string memory) {
return toString(abi.encodePacked(account));
}
| /**
* Utils
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | {
"func_code_index": [
12184,
12311
]
} | 1,197 | ||
CryptoTrunks | contracts/CryptoTrunks.sol | 0x375ea781c49eafedde07afe6196f885761f166ae | Solidity | CryptoTrunks | contract CryptoTrunks is ERC721, Ownable, ChainlinkClient, VRFConsumerBase {
using Counters for Counters.Counter;
// Pausable.
bool private _paused;
// Represents a minting user, for lookup from Chainlink fulfill.
struct User {
uint256 tokenId;
address addr;
}
// Generative
uint16 constant pr... | // Remix
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/token/ERC721/ERC721.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/access/Ownable.sol";
//import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.4.0/contracts/uti... | LineComment | toString | function toString(bytes memory data) private pure returns (string memory) {
bytes memory alphabet = "0123456789abcdef";
bytes memory str = new bytes(2 + data.length * 2);
str[0] = "0";
str[1] = "x";
for (uint i = 0; i < data.length; i++) {
str[2+i*2] = alphabet[uint(uint8(data[i] >> 4))];
str[3+i*... | // https://ethereum.stackexchange.com/a/58341/68257 | LineComment | v0.6.6+commit.6c089d02 | {
"func_code_index": [
12367,
12780
]
} | 1,198 | ||
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | CriptaliaRewards | function CriptaliaRewards() public {
symbol = "CRIPTRE";
name = "CRIPTALIA REWARDS";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[msg.sender] = _totalSupply;
Transfer(address(0), msg.sender, _totalSupply);
}
| // ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
463,
757
]
} | 1,199 | |
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | totalSupply | function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
| // ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
945,
1066
]
} | 1,200 | |
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | balanceOf | function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
| // ------------------------------------------------------------------------
// Get the token balance for account tokenOwner
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
1286,
1415
]
} | 1,201 | |
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | transfer | function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Transfer the balance from token owner's account to to account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
1759,
2036
]
} | 1,202 | |
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | approve | function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double... | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
2544,
2752
]
} | 1,203 | |
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | transferFrom | function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return... | // ------------------------------------------------------------------------
// Transfer tokens from the from account to the to account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the from account and
// - From account must have sufficient balance to transfer
// - S... | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
3283,
3641
]
} | 1,204 | |
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | allowance | function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
| // ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------ | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
3924,
4080
]
} | 1,205 | |
CriptaliaRewards | CriptaliaRewards.sol | 0x2c821a3ce3b5c0a471862eb63a2ef99a4d285d43 | Solidity | CriptaliaRewards | contract CriptaliaRewards is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// --------------------------------... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ---------------------------------------------------------------------------- | LineComment | approveAndCall | function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account. The spender contract function
// receiveApproval(...) is then executed
// --------------------------------------------------------------------... | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://8aa82eb5fe2ca991432d5ab5fda049a82fadf2c17c6a727dbc5bb442ea49e4de | {
"func_code_index": [
4435,
4752
]
} | 1,206 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.