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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
SuperXinfinitive | SuperXinfinitive.sol | 0x996fa957b5a5d83f29008aa0a11c9a209b3a5d8b | Solidity | EIP20Interface | contract EIP20Interface {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract sinc... | allowance | function allowance(address _owner, address _spender) public view returns (uint256 remaining);
| /// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent | NatSpecSingleLine | v0.4.19+commit.c4cbbb05 | bzzr://20d65a0a03cfc45c20aadf014a2ddeec63574e380c4b38800f4963200fd094f3 | {
"func_code_index": [
2043,
2141
]
} | 4,800 | |||
SuperXinfinitive | SuperXinfinitive.sol | 0x996fa957b5a5d83f29008aa0a11c9a209b3a5d8b | Solidity | SuperXinfinitive | contract SuperXinfinitive is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
string public name; //fancy name: eg Simon Bucks
uint8 public de... | /*
Implements EIP20 token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
.*/ | Comment | SuperXinfinitive | function SuperXinfinitive(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals =... | //An identifier: eg SBX | LineComment | v0.4.19+commit.c4cbbb05 | bzzr://20d65a0a03cfc45c20aadf014a2ddeec63574e380c4b38800f4963200fd094f3 | {
"func_code_index": [
442,
916
]
} | 4,801 | |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
251,
437
]
} | 4,802 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
707,
848
]
} | 4,803 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
1180,
1377
]
} | 4,804 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
1623,
2099
]
} | 4,805 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
2562,
2699
]
} | 4,806 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
... | /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
3224,
3574
]
} | 4,807 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
4026,
4161
]
} | 4,808 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
4675,
4846
]
} | 4,809 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | isContract | function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codeha... | /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
606,
1230
]
} | 4,810 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address... | /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `tr... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
2160,
2562
]
} | 4,811 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCall | function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
| /**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw ... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
3318,
3496
]
} | 4,812 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCall | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
3721,
3922
]
} | 4,813 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
4292,
4523
]
} | 4,814 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
4774,
5095
]
} | 4,815 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
94,
154
]
} | 4,816 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
237,
310
]
} | 4,817 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/ | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
534,
616
]
} | 4,818 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/ | NatSpecMultiLine | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
895,
983
]
} | 4,819 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
1647,
1726
]
} | 4,820 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
2039,
2141
]
} | 4,821 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
1476,
1564
]
} | 4,822 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
1678,
1770
]
} | 4,823 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
2403,
2491
]
} | 4,824 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | totalSupply | function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
2551,
2656
]
} | 4,825 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | balanceOf | function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
2714,
2838
]
} | 4,826 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
3046,
3230
]
} | 4,827 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
3777,
3933
]
} | 4,828 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
4075,
4249
]
} | 4,829 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
| /**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amou... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
4718,
5048
]
} | 4,830 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | increaseAllowance | function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
5452,
5743
]
} | 4,831 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | decreaseAllowance | function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
| /**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
6241,
6389
]
} | 4,832 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | addApprove | function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` c... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
6804,
7088
]
} | 4,833 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances... | /**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
*... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
7575,
8123
]
} | 4,834 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | _mint | function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
| /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
8399,
8705
]
} | 4,835 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | _burn | function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _to... | /**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
9032,
9455
]
} | 4,836 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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, amount)... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
9890,
10239
]
} | 4,837 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | _approveCheck | function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(send... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero... | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
10684,
11276
]
} | 4,838 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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 | _setupDecimals | function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
| /**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
12995,
13090
]
} | 4,839 |
MatrixETF | MatrixETF.sol | 0xc21f36b84b03711465f8c0084ca60985b9e570c9 | Solidity | MatrixETF | contract MatrixETF is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
... | /**
* @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.6.6+commit.6c089d02 | None | ipfs://64d9eca76fd44ac4e2f4a29ba8b04a9592bd6b2e2acd21cd45b1beb40a8ec800 | {
"func_code_index": [
13688,
13785
]
} | 4,840 |
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
94,
154
]
} | 4,841 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
237,
310
]
} | 4,842 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | transfer | function transfer(address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.s
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
535,
617
]
} | 4,843 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | allowance | function allowance(address owner, address spender) external view returns (uint256);
| /**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
896,
984
]
} | 4,844 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
1648,
1727
]
} | 4,845 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
| /**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
2040,
2142
]
} | 4,846 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | isContract | function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codeha... | /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
606,
1230
]
} | 4,847 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address... | /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `tr... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
2160,
2562
]
} | 4,848 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCall | function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
| /**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw ... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
3318,
3496
]
} | 4,849 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCall | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
3721,
3922
]
} | 4,850 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
| /**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
4292,
4523
]
} | 4,851 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will ... | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
4774,
5095
]
} | 4,852 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
259,
445
]
} | 4,853 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
723,
864
]
} | 4,854 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
1162,
1359
]
} | 4,855 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
1613,
2089
]
} | 4,856 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
2560,
2697
]
} | 4,857 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
3188,
3471
]
} | 4,858 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
3931,
4066
]
} | 4,859 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
4546,
4717
]
} | 4,860 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | owner | function owner() public view returns (address) {
return address(0);
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
497,
585
]
} | 4,861 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
1143,
1266
]
} | 4,862 | ||
$LOFI | $LOFI.sol | 0x6a1699f4ef54b9b99d7d8618f95d3445b961aa3d | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | GNU GPLv2 | ipfs://abcc5839f01357892f69962246a33e4beedec36f27ea39b54a660084726f9cf6 | {
"func_code_index": [
1416,
1665
]
} | 4,863 | ||
CubegoIron | CubegoIron.sol | 0x18307523c553e1b826c4bc63faec7fbddfc920e4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, tr... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://18f1b66febbaaf6ba7a8cf44bfa6a9522da816fb637ad9a190261a217af3e71e | {
"func_code_index": [
89,
266
]
} | 4,864 | |
CubegoIron | CubegoIron.sol | 0x18307523c553e1b826c4bc63faec7fbddfc920e4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, tr... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://18f1b66febbaaf6ba7a8cf44bfa6a9522da816fb637ad9a190261a217af3e71e | {
"func_code_index": [
350,
630
]
} | 4,865 | |
CubegoIron | CubegoIron.sol | 0x18307523c553e1b826c4bc63faec7fbddfc920e4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, tr... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://18f1b66febbaaf6ba7a8cf44bfa6a9522da816fb637ad9a190261a217af3e71e | {
"func_code_index": [
744,
860
]
} | 4,866 | |
CubegoIron | CubegoIron.sol | 0x18307523c553e1b826c4bc63faec7fbddfc920e4 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, tr... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://18f1b66febbaaf6ba7a8cf44bfa6a9522da816fb637ad9a190261a217af3e71e | {
"func_code_index": [
924,
1054
]
} | 4,867 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Priced | contract Priced is Ownable {
uint256 private price = 500000000000000000; // Basic price in wei
uint16 private zMax = 1600; // Max z for get price percent
uint256 private zPrice = 25000000000000000; // Price for each item in z index (in wei)
uint8 private commis... | /***********************************************
***************
* Priced contract
***************
**********************************************/ | NatSpecMultiLine | setPriceData | function setPriceData(uint256 _price, uint16 _zMax, uint256 _zPrice, uint8 _commission) external onlyOwner {
price = _price;
zMax = _zMax;
zPrice = _zPrice;
commission = _commission;
}
| // Update commission in percent | LineComment | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
384,
633
]
} | 4,868 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Control | contract Control is Ownable {
/**
* Withdraw balance
*/
function withdrawBalance(address recipient, uint256 value) external onlyOwner {
require(value > 0);
require(value < address(this).balance);
recipient.transfer(value);
}
} | /***********************************************
***************
* Control contract
* == FINAL ==
***************
**********************************************/ | NatSpecMultiLine | withdrawBalance | function withdrawBalance(address recipient, uint256 value) external onlyOwner {
require(value > 0);
require(value < address(this).balance);
recipient.transfer(value);
}
| /**
* Withdraw balance
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
74,
279
]
} | 4,869 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Storage | contract Storage {
struct Star {
address owner; // Star owner
uint8 gid; // Star galaxy id
uint8 zIndex; // Star z
uint16 box; // Current xy box
uint8 inbox; // Random x-y in box
uint8 stype; // Star type
uint8 color; // St... | /***********************************************
***************
* Storage contract
***************
**********************************************/ | NatSpecMultiLine | addStar | function addStar(address owner, uint8 gid, uint8 zIndex, uint16 box, uint8 inbox, uint8 stype, uint8 color, uint256 price) internal returns(uint256) {
Star memory _star = Star({
owner: owner,
gid: gid, zIndex: zIndex, box: box, inbox: inbox,
stype: stype, color: color,
price: pr... | /**
* Add new star
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
965,
1500
]
} | 4,870 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Storage | contract Storage {
struct Star {
address owner; // Star owner
uint8 gid; // Star galaxy id
uint8 zIndex; // Star z
uint16 box; // Current xy box
uint8 inbox; // Random x-y in box
uint8 stype; // Star type
uint8 color; // St... | /***********************************************
***************
* Storage contract
***************
**********************************************/ | NatSpecMultiLine | getStar | function getStar(uint256 starId) external view returns(address owner, uint8 gid, uint8 zIndex, uint16 box, uint8 inbox,
uint8 stype, uint8 color,
uint256 price, uint256 sell, bool deleted,
... | /**
* Get star by id
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
2618,
3493
]
} | 4,871 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | setValidationData | function setValidationData(uint16 _zMin, uint16 _zMax, uint8 _lName, uint8 _lMessage, uint8 _maxCT, uint8 _maxIR, uint16 _boxSize) external onlyOwner {
zMin = _zMin;
zMax = _zMax;
lName = _lName;
lMessage = _lMessage;
maxCT = _maxCT;
maxIRandom = _maxIR;
boxSiz... | /**
* Set validation data
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
626,
1056
]
} | 4,872 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | setBoxCount | function setBoxCount(uint16 z, uint16 count) external onlyOwner {
require(isValidZ(z));
boxes[getZIndex(z)] = count;
}
| /**
* Get set boxes
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
1197,
1343
]
} | 4,873 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | getZIndex | function getZIndex(uint16 z) internal view returns(uint8 zIndex) {
return uint8(z / boxSize);
}
| /**
* Get z index and z count
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
1672,
1786
]
} | 4,874 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | isValidGid | function isValidGid(uint8 gid) internal view returns(bool) {
return gid > 0 && gid <= gidMax;
}
| /**
* Validate star parameters
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
1977,
2091
]
} | 4,875 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | isValidNameLength | function isValidNameLength(string name) internal view returns(bool) {
return UTF8.getStringLength(name) <= lName;
}
| /**
* Check name and message length
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
2425,
2559
]
} | 4,876 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | isValidMsgValue | function isValidMsgValue(uint256 price) internal returns(bool) {
if (msg.value < price) return false;
if (msg.value > price)
msg.sender.transfer(msg.value - price);
return true;
}
| /**
* Check is valid msg value
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
2764,
2993
]
} | 4,877 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | getRandom16 | function getRandom16(uint16 min, uint16 max) private returns(uint16) {
nonce++;
return Math.rand16(nonce, min, max);
}
| /**
* Get random number
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
3042,
3188
]
} | 4,878 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Validation | contract Validation is Priced, Storage {
uint8 private gidMax = 5;
uint16 private zMin = 100;
uint16 private zMax = 1600;
uint8 private lName = 25;
uint8 private lMessage = 140;
uint8 private maxCT = 255; // Max color, types
uint256 private nonce ... | /***********************************************
***************
* Validation contract
***************
**********************************************/ | NatSpecMultiLine | getRandomPosition | function getRandomPosition(uint8 gid, uint8 zIndex) internal returns(uint16 box, uint8 inbox) {
uint16 boxCount = getBoxCountZIndex(zIndex);
uint16 randBox = 0;
if (boxCount == 0) revert();
uint8 ii = maxIRandom;
bool valid = false;
while (!valid && ii > 0) {
randBox = getRan... | /**
* Get random star position
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
3496,
4045
]
} | 4,879 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Stars | contract Stars is Control, Validation {
// Contrac events
event StarCreated(uint256 starId);
event StarUpdated(uint256 starId, uint8 reason);
event StarDeleted(uint256 starId, address owner);
event StarSold (uint256 starId, address seller, address buyer, uint256 price);
event StarGifted ... | /***********************************************
***************
* Stars general contract
***************
**********************************************/ | NatSpecMultiLine | Stars | function Stars() public {
// Add star with zero index
uint256 starId = addStar(address(0), 0, 0, 0, 0, 0, 0, 0);
setStarNameMessage(starId, "Universe", "Big Bang!");
}
| /**
* Constructor
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
416,
620
]
} | 4,880 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Stars | contract Stars is Control, Validation {
// Contrac events
event StarCreated(uint256 starId);
event StarUpdated(uint256 starId, uint8 reason);
event StarDeleted(uint256 starId, address owner);
event StarSold (uint256 starId, address seller, address buyer, uint256 price);
event StarGifted ... | /***********************************************
***************
* Stars general contract
***************
**********************************************/ | NatSpecMultiLine | createStar | function createStar(uint8 gid, uint16 z, string name, string message) external payable {
// Check basic requires
require(isValidGid(gid));
require(isValidZ(z));
require(isValidNameLength(name));
require(isValidMessageLength(message));
// Get zIndex
uint8 zIndex = getZIndex(z);
... | /**
* Create star
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
663,
1424
]
} | 4,881 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Stars | contract Stars is Control, Validation {
// Contrac events
event StarCreated(uint256 starId);
event StarUpdated(uint256 starId, uint8 reason);
event StarDeleted(uint256 starId, address owner);
event StarSold (uint256 starId, address seller, address buyer, uint256 price);
event StarGifted ... | /***********************************************
***************
* Stars general contract
***************
**********************************************/ | NatSpecMultiLine | updateStar | function updateStar(uint256 starId, string name, string message) external payable {
// Exists and owned star
require(starExists(starId));
require(isStarOwner(starId, msg.sender));
// Check basic requires
require(isValidNameLength(name));
require(isValidMessageLength(message));
... | /**
* Update start method
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
1861,
2483
]
} | 4,882 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Stars | contract Stars is Control, Validation {
// Contrac events
event StarCreated(uint256 starId);
event StarUpdated(uint256 starId, uint8 reason);
event StarDeleted(uint256 starId, address owner);
event StarSold (uint256 starId, address seller, address buyer, uint256 price);
event StarGifted ... | /***********************************************
***************
* Stars general contract
***************
**********************************************/ | NatSpecMultiLine | deleteStar | function deleteStar(uint256 starId) external payable {
// Exists and owned star
require(starExists(starId));
require(isStarOwner(starId, msg.sender));
// Get star update price
uint256 commission = getCommission(stars[starId].price);
require(isValidMsgValue(commission));
// Update ... | /**
* Delete star
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
2526,
2979
]
} | 4,883 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Stars | contract Stars is Control, Validation {
// Contrac events
event StarCreated(uint256 starId);
event StarUpdated(uint256 starId, uint8 reason);
event StarDeleted(uint256 starId, address owner);
event StarSold (uint256 starId, address seller, address buyer, uint256 price);
event StarGifted ... | /***********************************************
***************
* Stars general contract
***************
**********************************************/ | NatSpecMultiLine | sellStar | function sellStar(uint256 starId, uint256 sellPrice) external {
// Exists and owned star
require(starExists(starId));
require(isStarOwner(starId, msg.sender));
require(sellPrice < 10**28);
// Set star sell price
setStarSellPrice(starId, sellPrice);
emit StarUpdated(starId, 2);
} ... | /**
* Set star sell price
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
3030,
3388
]
} | 4,884 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Stars | contract Stars is Control, Validation {
// Contrac events
event StarCreated(uint256 starId);
event StarUpdated(uint256 starId, uint8 reason);
event StarDeleted(uint256 starId, address owner);
event StarSold (uint256 starId, address seller, address buyer, uint256 price);
event StarGifted ... | /***********************************************
***************
* Stars general contract
***************
**********************************************/ | NatSpecMultiLine | giftStar | function giftStar(uint256 starId, address recipient) external payable {
// Check star exists owned
require(starExists(starId));
require(recipient != address(0));
require(isStarOwner(starId, msg.sender));
require(!isStarOwner(starId, recipient));
// Get gift commission
uint256 commis... | /**
* Gift star
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
3429,
4086
]
} | 4,885 | |
Stars | Stars.sol | 0x6360c66db2fbf3a39ae3db7f0ed0b551043f13d1 | Solidity | Stars | contract Stars is Control, Validation {
// Contrac events
event StarCreated(uint256 starId);
event StarUpdated(uint256 starId, uint8 reason);
event StarDeleted(uint256 starId, address owner);
event StarSold (uint256 starId, address seller, address buyer, uint256 price);
event StarGifted ... | /***********************************************
***************
* Stars general contract
***************
**********************************************/ | NatSpecMultiLine | buyStar | function buyStar(uint256 starId, string name, string message) external payable {
// Exists and NOT owner
require(starExists(starId));
require(!isStarOwner(starId, msg.sender));
require(stars[starId].sell > 0);
// Get sell commission and check value
uint256 commission = getCommission(star... | /**
* Buy star
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://9da1480a31b5117c30a4ebb09152979e780f61e0431a5b04b240d7dcc0fc13ff | {
"func_code_index": [
4126,
5049
]
} | 4,886 | |
LeftyMfers | contracts/LeftyMfers.sol | 0x6e03c0e7c85e67efa4930409f98b61f0096c1058 | Solidity | LeftyMfers | contract LeftyMfers is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.006969 ether;
uint256 public maxSupply = 7000;
uint256 public maxMintAmount = 20;
uint256 public nft... | _baseURI | function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
| // internal | LineComment | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://2027d3ec97d5cadb6398f1ea1a1bab2e709bbdcabbd286b8bdabe79f0484a5f8 | {
"func_code_index": [
820,
925
]
} | 4,887 | ||
LeftyMfers | contracts/LeftyMfers.sol | 0x6e03c0e7c85e67efa4930409f98b61f0096c1058 | Solidity | LeftyMfers | contract LeftyMfers is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.006969 ether;
uint256 public maxSupply = 7000;
uint256 public maxMintAmount = 20;
uint256 public nft... | mint | function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply... | // public | LineComment | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://2027d3ec97d5cadb6398f1ea1a1bab2e709bbdcabbd286b8bdabe79f0484a5f8 | {
"func_code_index": [
941,
1875
]
} | 4,888 | ||
LeftyMfers | contracts/LeftyMfers.sol | 0x6e03c0e7c85e67efa4930409f98b61f0096c1058 | Solidity | LeftyMfers | contract LeftyMfers is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.006969 ether;
uint256 public maxSupply = 7000;
uint256 public maxMintAmount = 20;
uint256 public nft... | reveal | function reveal() public onlyOwner {
revealed = true;
}
| //only owner | LineComment | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://2027d3ec97d5cadb6398f1ea1a1bab2e709bbdcabbd286b8bdabe79f0484a5f8 | {
"func_code_index": [
2998,
3066
]
} | 4,889 | ||
ClinTex | contracts/ClinTex.sol | 0xcb8fb2438a805664cd8c3e640b85ac473da5be87 | Solidity | ClinTex | contract ClinTex is ERC20Capped, Ownable {
constructor(
string memory name,
string memory symbol,
uint256 cap
) ERC20Capped(cap) ERC20(name, symbol) {}
/// @dev See {ERC20Capped-_mint}
function mint(address to, uint256 amount) external onlyOwner {
_mint(to, amou... | /**
* @title ERC20 contract with supply cap
* @dev See {ERC20Capped}
*/ | NatSpecMultiLine | mint | function mint(address to, uint256 amount) external onlyOwner {
_mint(to, amount);
}
| /// @dev See {ERC20Capped-_mint} | NatSpecSingleLine | v0.8.12+commit.f00d7308 | {
"func_code_index": [
230,
332
]
} | 4,890 | ||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | totalSupply | function totalSupply() constant returns (uint256 supply) {}
| /// @return total amount of tokens | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
60,
124
]
} | 4,891 | |||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | balanceOf | function balanceOf(address _owner) constant returns (uint256 balance) {}
| /// @param _owner The address from which the balance will be retrieved
/// @return The balance | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
232,
309
]
} | 4,892 | |||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transfer | function transfer(address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
546,
623
]
} | 4,893 | |||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
946,
1042
]
} | 4,894 | |||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | approve | function approve(address _spender, uint256 _value) returns (bool success) {}
| /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
1326,
1407
]
} | 4,895 | |||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | allowance | function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
| /// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent | NatSpecSingleLine | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
1615,
1712
]
} | 4,896 | |||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | RBCTheRoyalBankofCanadaCertifiedDeposit | contract RBCTheRoyalBankofCanadaCertifiedDeposit is StandardToken { // Token is coded ECR20 Contract.
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way inf... | RBCTheRoyalBankofCanadaCertifiedDeposit | function RBCTheRoyalBankofCanadaCertifiedDeposit() {
balances[msg.sender] = 999000000000000000000000000000000000000; // Give the creator all initial geo-spatially digitized tokens.(CHANGE THIS)
totalSupply = 999000000000000000000000000000000000000; // Update total supply a... | // Where should the raised ETH go?
// This is a constructor function
// which means the following function name has to match the contract name declared above | LineComment | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
1215,
2356
]
} | 4,897 | |||
RBCTheRoyalBankofCanadaCertifiedDeposit | RBCTheRoyalBankofCanadaCertifiedDeposit.sol | 0x16bfda382595bc50ea278b5475430db9ce6657a7 | Solidity | RBCTheRoyalBankofCanadaCertifiedDeposit | contract RBCTheRoyalBankofCanadaCertifiedDeposit is StandardToken { // Token is coded ECR20 Contract.
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way inf... | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually s... | /* Approves and then calls the receiving contract */ | Comment | v0.4.24+commit.e67f0147 | bzzr://67b1e3251d57ebd1253b22295fd047f424e6a74997d08ebc9e67749ef3da40b5 | {
"func_code_index": [
2957,
3762
]
} | 4,898 | |||
v3DOGE | v3DOGE.sol | 0xbfe52d7048cf55d272e60122c418ca63f9299b75 | Solidity | v3DOGE | contract v3DOGE is Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 0;
string private _name = 'v3Doge';
string private _symbol = 'v3DOG... | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://c2dc6d2b28a7548f08591a8115db4edcebcd8dbd733223d2feb0cb62641384a1 | {
"func_code_index": [
896,
984
]
} | 4,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.