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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
AccountCreator | AccountCreator.sol | 0x185479fb2caecba11227db4186046496d6230243 | Solidity | Account | contract Account {
// The implementation of the proxy
address public implementation;
// Logic manager
address public manager;
// The enabled static calls
mapping (bytes4 => address) public enabled;
event EnabledStaticCall(address indexed module, bytes4 indexed method);
... | function() external payable {
if(msg.data.length > 0) {
address logic = enabled[msg.sig];
if(logic == address(0)) {
emit Received(msg.value, msg.sender, msg.data);
}
else {
require(LogicManager(manager).isAuthorized(logic), "must be an authorized logic ... | /**
* @dev This method makes it possible for the wallet to comply to interfaces expecting the wallet to
* implement specific static methods. It delegates the static call to a target contract if the data corresponds
* to an enabled method, or logs the call otherwise.
*/ | NatSpecMultiLine | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://539b439b1d99957bba306aefb78727634b09abe5cdb32db42706c8c86213e290 | {
"func_code_index": [
2999,
3875
]
} | 19,400 | |||
AccountCreator | AccountCreator.sol | 0x185479fb2caecba11227db4186046496d6230243 | Solidity | AccountCreator | contract AccountCreator is MultiOwned {
address public logicManager;
address public accountStorage;
address public accountImpl;
// address[] public logics;
// *************** Events *************************** //
event AccountCreated(address indexed wallet, address[] keys, address[] ba... | createAccount | function createAccount(address[] calldata _keys, address[] calldata _backups) external onlyMultiOwners {
AccountProxy accountProxy = new AccountProxy(accountImpl);
Account(address(accountProxy)).init(logicManager, accountStorage, LogicManager(logicManager).getAuthorizedLogics(), _keys, _backups);
emit ... | // *************** Constructor ********************** //
// constructor(address _mgr, address _storage, address _accountImpl) public {
// logicManager = _mgr;
// accountStorage = _storage;
// accountImpl = _accountImpl;
// // logics = _logics;
// }
// *************** External Functions *****************... | LineComment | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://539b439b1d99957bba306aefb78727634b09abe5cdb32db42706c8c86213e290 | {
"func_code_index": [
746,
1145
]
} | 19,401 | ||
AccountCreator | AccountCreator.sol | 0x185479fb2caecba11227db4186046496d6230243 | Solidity | AccountCreator | contract AccountCreator is MultiOwned {
address public logicManager;
address public accountStorage;
address public accountImpl;
// address[] public logics;
// *************** Events *************************** //
event AccountCreated(address indexed wallet, address[] keys, address[] ba... | close | function close() external onlyMultiOwners {
selfdestruct(msg.sender);
emit Closed(msg.sender);
}
| // *************** Suicide ********************* // | LineComment | v0.5.4+commit.9549d8ff | GNU GPLv3 | bzzr://539b439b1d99957bba306aefb78727634b09abe5cdb32db42706c8c86213e290 | {
"func_code_index": [
1431,
1555
]
} | 19,402 | ||
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
251,
437
]
} | 19,403 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
707,
848
]
} | 19,404 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
1180,
1377
]
} | 19,405 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
1623,
2099
]
} | 19,406 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
2562,
2699
]
} | 19,407 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
3224,
3574
]
} | 19,408 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
4026,
4161
]
} | 19,409 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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 l... | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
4675,
4846
]
} | 19,410 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
606,
1230
]
} | 19,411 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
2160,
2562
]
} | 19,412 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
3318,
3496
]
} | 19,413 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
3721,
3922
]
} | 19,414 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
4292,
4523
]
} | 19,415 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
4774,
5095
]
} | 19,416 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
94,
154
]
} | 19,417 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
237,
310
]
} | 19,418 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
534,
616
]
} | 19,419 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
895,
983
]
} | 19,420 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
1647,
1726
]
} | 19,421 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | 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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
2039,
2141
]
} | 19,422 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
1471,
1559
]
} | 19,423 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
1673,
1765
]
} | 19,424 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
2398,
2486
]
} | 19,425 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
2546,
2651
]
} | 19,426 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
2709,
2833
]
} | 19,427 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
3041,
3225
]
} | 19,428 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
3772,
3928
]
} | 19,429 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
4070,
4244
]
} | 19,430 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
4713,
5043
]
} | 19,431 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
5447,
5738
]
} | 19,432 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
6236,
6384
]
} | 19,433 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
6799,
7083
]
} | 19,434 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
7570,
8118
]
} | 19,435 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
8394,
8700
]
} | 19,436 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
9027,
9450
]
} | 19,437 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
9885,
10234
]
} | 19,438 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
10679,
11271
]
} | 19,439 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
12990,
13085
]
} | 19,440 |
LIKE | LIKE.sol | 0x8a0b9f3835af5abf2a2a421ae4b012b80e0f925a | Solidity | LIKE | contract LIKE 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;
ma... | /**
* @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.12+commit.27d51765 | None | ipfs://1142cbf4c864033540d9c36222a66dc48083eba5fc98b2cfe24bb90ac03abbd4 | {
"func_code_index": [
13683,
13780
]
} | 19,441 |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
89,
272
]
} | 19,442 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @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 c;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
356,
629
]
} | 19,443 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @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 Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
744,
860
]
} | 19,444 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
924,
1060
]
} | 19,445 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | Ownable | function Ownable() public {
owner = msg.sender;
}
| /**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
261,
321
]
} | 19,446 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
640,
816
]
} | 19,447 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
199,
287
]
} | 19,448 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
T... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
445,
836
]
} | 19,449 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
1042,
1154
]
} | 19,450 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
401,
853
]
} | 19,451 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* ... | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
1485,
1675
]
} | 19,452 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
1999,
2130
]
} | 19,453 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
2596,
2860
]
} | 19,454 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
3331,
3741
]
} | 19,455 | |
PAD | PAD.sol | 0xdc9f5b24b910addcb2e3be7ff75caf20e1fcdcf3 | Solidity | PAD | contract PAD is StandardToken, Ownable {
// Constants
string public constant name = "parabox token";
string public constant symbol = "PAD";
uint8 public constant decimals = 2;
uint256 public constant INITIAL_SUPPLY = 4200000000 * (10 ** uint256(decimals));
uint public amountRais... | /*
full name:parabox token
*/ | Comment | batchTransfer | function batchTransfer(address[] _recipients, uint[] _values) onlyOwner public returns (bool) {
require( _recipients.length > 0 && _recipients.length == _values.length);
uint total = 0;
for(uint i = 0; i < _values.length; i++){
total = total.add(_values[i]);
}
require(total <= balanc... | /* Batch token transfer. Used by contract creator to distribute initial tokens to holders */ | Comment | v0.4.18+commit.9cf6e910 | bzzr://a3eca76223149643f7db99dd2786ab0832ec5bfbceabd5c96e46caad1676b927 | {
"func_code_index": [
1843,
2517
]
} | 19,456 | |
Crowdsale | Crowdsale.sol | 0x0acbcc45dde258b18c11b16b06bdc64fd91913ac | Solidity | Crowdsale | contract Crowdsale is Base, Owned {
using SafeMath for uint256;
enum State { INIT, ICO, CLOSED, PAUSE }
uint public constant DECIMALS = 10**18;
uint public constant WEI_DECIMALS = 10**18;
uint public constant MAX_SUPPLY = 3400000000 * DECIMALS;
mapping (address => bool) investors;
... | _mint | function _mint(address _to, uint _amount)
noAnyReentrancy
internal
{
_increaseSupply(_amount);
IToken(token).mint(_to, _amount);
Transfer(_to, _amount);
}
| //==================== Internal Methods ================= | LineComment | v0.4.24+commit.e67f0147 | bzzr://56e0603fa20bba9b4b0683aefad525af50cbe4c31935944d1a601d5b0aeee68a | {
"func_code_index": [
2867,
3081
]
} | 19,457 | |||
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | /////////////////////////////////////////////////////////////////////////////// | NatSpecSingleLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a... | /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
89,
476
]
} | 19,458 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | /////////////////////////////////////////////////////////////////////////////// | NatSpecSingleLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
560,
840
]
} | 19,459 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | /////////////////////////////////////////////////////////////////////////////// | NatSpecSingleLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
954,
1070
]
} | 19,460 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | /////////////////////////////////////////////////////////////////////////////// | NatSpecSingleLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
1134,
1264
]
} | 19,461 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | tokenSaleTokenBalance | function tokenSaleTokenBalance() public view returns(uint) {
return token.balanceOf(thisContractAddress);
}
| // check balance of this smart contract | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
3705,
3825
]
} | 19,462 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | getAnyAddressTokenBalance | function getAnyAddressTokenBalance(address _address) public view returns(uint) {
return token.balanceOf(_address);
}
| // check the token balance of any ethereum address | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
3886,
4015
]
} | 19,463 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | tokenSaleHasFinished | function tokenSaleHasFinished() public view returns (bool) {
return now > closingTime;
}
| // confirm if The Token Sale has finished | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
4065,
4164
]
} | 19,464 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | burnUnsoldTokens | function burnUnsoldTokens() public {
require(tokenSaleIsPaused == false);
require(tokenSaleHasFinished() == true);
token.transfer(tokenBurnAddress, tokenSaleTokenBalance());
emit TokensBurned("tokens sent to TokenBurn contract", now);
}
| // this function will send any unsold tokens to the null TokenBurn contract address
// once the crowdsale is finished, anyone can publicly call this function! | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
4334,
4604
]
} | 19,465 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | pauseTokenSale | function pauseTokenSale() onlyAdmin public {
// confirm the token sale hasn't already completed
require(tokenSaleHasFinished() == false);
// confirm the token sale isn't already paused
require(tokenSaleIsPaused == false);
// pause the sale and note the time of the pause
tok... | // function to temporarily pause token sale if needed | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
4668,
5123
]
} | 19,466 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | resumeTokenSale | function resumeTokenSale() onlyAdmin public {
// confirm the token sale is currently paused
require(tokenSaleIsPaused == true);
tokenSaleResumedTime = now;
// now calculate the difference in time between the pause time
// and the resume time, to establish how long the sa... | // function to resume token sale | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
5166,
6288
]
} | 19,467 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | function () external payable {
buyTokens(msg.sender);
}
| // -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
// ----------------------------------------------------------------------------
// fallback function ***DO NOT OVERRIDE***
// allows purchase of tokens directly from MEW and other wallets
// will co... | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
7318,
7384
]
} | 19,468 | ||
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | buyTokens | function buyTokens(address buyer) public payable {
// check Crowdsale is open (can disable for testing)
require(openingTime <= block.timestamp);
require(block.timestamp < closingTime);
// minimum purchase of 100 tokens (0.1 eth)
require(msg.value >= minSpend);
// maximum purchase per... | // ----------------------------------------------------------------------------
// function for front-end token purchase on our website ***DO NOT OVERRIDE***
// buyer = Address of the wallet performing the token purchase
// ---------------------------------------------------------------------------- | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
7694,
9060
]
} | 19,469 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | preValidatePurchase | function preValidatePurchase(
address buyer,
uint256 weiAmount
)
internal pure
{
require(buyer != address(0));
require(weiAmount != 0);
}
| // -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
// ----------------------------------------------------------------------------
// Validation of an incoming purchase
// --------------------------------------------------------------------------... | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
9400,
9574
]
} | 19,470 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | postValidatePurchase | function postValidatePurchase(
address,
uint256
)
internal pure
{
// optional override
}
| // ----------------------------------------------------------------------------
// Validation of an executed purchase
// ---------------------------------------------------------------------------- | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
9778,
9898
]
} | 19,471 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | deliverTokens | function deliverTokens(
address buyer,
uint256 tokenAmount
)
internal
{
token.transfer(buyer, tokenAmount);
}
| // ----------------------------------------------------------------------------
// Source of tokens
// ---------------------------------------------------------------------------- | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
10084,
10225
]
} | 19,472 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | processPurchase | function processPurchase(
address buyer,
uint256 tokenAmount
)
internal
{
deliverTokens(buyer, tokenAmount);
}
| // ----------------------------------------------------------------------------
// The following function is executed when a purchase has been validated
// and is ready to be executed
// ---------------------------------------------------------------------------- | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
10497,
10639
]
} | 19,473 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | updatePurchasingState | function updatePurchasingState(
address,
uint256
)
internal pure
{
// optional override
}
| // ----------------------------------------------------------------------------
// Override for extensions that require an internal state to check for
// validity (current user contributions, etc.)
// ---------------------------------------------------------------------------- | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
10925,
11046
]
} | 19,474 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | getTokenAmount | function getTokenAmount(uint256 weiAmount)
internal view returns (uint256)
{
return weiAmount.div(rate);
}
| // ----------------------------------------------------------------------------
// Override to extend the way in which ether is converted to tokens.
// _weiAmount Value in wei to be converted into tokens
// return Number of tokens that can be purchased with the specified _weiAmount
// ----------------------------------... | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
11417,
11542
]
} | 19,475 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | forwardFunds | function forwardFunds() internal {
ethRaisedAddress.transfer(msg.value);
}
| // ----------------------------------------------------------------------------
// how ETH is stored/forwarded on purchases.
// Sent to the EthRaised Contract
// ---------------------------------------------------------------------------- | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
11788,
11873
]
} | 19,476 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | maximumRaised | function maximumRaised() public view returns(uint) {
return maxWeiRaised;
}
| // functions for tokensale information on the website | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
11938,
12032
]
} | 19,477 | |
TokenSale | TokenSale.sol | 0x202f291e30fe4aa626792ae01c35eaf7153b44b9 | Solidity | TokenSale | contract TokenSale {
using SafeMath for uint256;
EthertoteToken public token;
address public admin;
address public thisContractAddress;
// address of the TOTE token original smart contract
address public tokenContractAddress = 0x42be9831FFF77972c1D0E1eC0aA9bdb3CaA04D47;
// address of To... | // ----------------------------------------------------------------------------
// Main Contract
// ---------------------------------------------------------------------------- | LineComment | delayOpeningTime | function delayOpeningTime(uint256 _openingTime) onlyAdmin public {
openingTime = _openingTime;
closingTime = openingTime.add(7 days);
preIcoPhaseCountdown = openingTime;
icoPhaseCountdown = closingTime;
postIcoPhaseCountdown = closingTime.add(14 days);
}
| // special function to delay the token sale if necessary | LineComment | v0.4.24+commit.e67f0147 | bzzr://50c2c84e7dc7a3d5652a69710599f74b5f0dacc6ad981efc4e60e108da77ab54 | {
"func_code_index": [
12295,
12586
]
} | 19,478 | |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
642,
823
]
} | 19,479 |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public override returns (bool trans1) {
require(_to != address(0));
//require(canTransfer(msg.sender));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
324,
737
]
} | 19,480 |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view override returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
870,
991
]
} | 19,481 |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public override returns (bool trans) {
require(_to != address(0));
// require(canTransfer(msg.sender));
uint256 _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this cond... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
1339,
1949
]
} | 19,482 |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public override returns (bool hello) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* ... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
2581,
2791
]
} | 19,483 |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view override returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
3031,
3182
]
} | 19,484 |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | StandardToken | contract StandardToken is ERC20Basic, Ownable {
uint256 public totalSupply;
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
3427,
3705
]
} | 19,485 |
JVJ | JVJ.sol | 0x4a45d4a46d56248ea0556ae1335fe521f4626ea8 | Solidity | BurnableToken | contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
require(_value > 0);
require(_valu... | /**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/ | NatSpecMultiLine | burn | function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
... | /**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://907a3ab54dce3a80591ebba9a35ab989f1d5efbda1c96cc20d18d39d424f581a | {
"func_code_index": [
225,
770
]
} | 19,486 |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | 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.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
89,
266
]
} | 19,487 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | 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.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
350,
630
]
} | 19,488 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | 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.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
744,
860
]
} | 19,489 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | 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.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
924,
1054
]
} | 19,490 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
199,
287
]
} | 19,491 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
445,
777
]
} | 19,492 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
983,
1087
]
} | 19,493 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
401,
858
]
} | 19,494 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| /**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* ... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
1490,
1685
]
} | 19,495 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
2009,
2140
]
} | 19,496 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseApproval | function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
2606,
2875
]
} | 19,497 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transf... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseApproval | function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approva... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spend... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
3346,
3761
]
} | 19,498 | |
SynergisSGRToken | SynergisSGRToken.sol | 0x3d23a5bfadf33cb0aeb47d607605ffe9f9596327 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://805d6b17bb31e66ad02fe20cd9ab5ae752bdc7390e599206d29da066a4aa41a4 | {
"func_code_index": [
635,
816
]
} | 19,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.