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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 returns (bool) {
_transfer(_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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
2513,
2678
]
} | 15,400 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
2736,
2877
]
} | 15,401 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
3019,
3178
]
} | 15,402 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount));
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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
3647,
3914
]
} | 15,403 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
| /**
* @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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
4318,
4534
]
} | 15,404 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue));
return true;
}
| /**
* @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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
5032,
5258
]
} | 15,405 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 {
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[sender] = ... | /**
* @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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
5743,
6238
]
} | 15,406 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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) internal {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(addre... | /** @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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
6625,
7001
]
} | 15,407 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(acc... | /**
* @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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
7425,
7803
]
} | 15,408 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 {
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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
8238,
8582
]
} | 15,409 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
8909,
9004
]
} | 15,410 |
ERC20 | ERC20.sol | 0x5be510f73f0ac9533bc0ab6a0ffab0fa7144e01b | Solidity | ERC20 | contract ERC20 is Context, IERC20,owned {
using SafeMath for uint256;
// using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string... | /**
* @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 { }
| /**
* @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.5.17+commit.d19bba13 | None | bzzr://002d185c6e3f9cf50b8543bafc70f549d08cdf78f82add6f54afaffc75b85d1a | {
"func_code_index": [
9602,
9692
]
} | 15,411 |
SchnoodleTimelockFactory | @openzeppelin/contracts-upgradeable/token/ERC20/utils/TokenTimelockUpgradeable.sol | 0x8b37893f470e0237e523b1efa0edfbc9dc445cf9 | Solidity | TokenTimelockUpgradeable | contract TokenTimelockUpgradeable is Initializable {
using SafeERC20Upgradeable for IERC20Upgradeable;
// ERC20 basic token contract being held
IERC20Upgradeable private _token;
// beneficiary of tokens after they are released
address private _beneficiary;
// timestamp when token release is e... | /**
* @dev A token holder contract that will allow a beneficiary to extract the
* tokens after a given release time.
*
* Useful for simple vesting schedules like "advisors get all of their tokens
* after 1 year".
*/ | NatSpecMultiLine | token | function token() public view virtual returns (IERC20Upgradeable) {
return _token;
}
| /**
* @return the token being held.
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1031,
1130
]
} | 15,412 | ||
SchnoodleTimelockFactory | @openzeppelin/contracts-upgradeable/token/ERC20/utils/TokenTimelockUpgradeable.sol | 0x8b37893f470e0237e523b1efa0edfbc9dc445cf9 | Solidity | TokenTimelockUpgradeable | contract TokenTimelockUpgradeable is Initializable {
using SafeERC20Upgradeable for IERC20Upgradeable;
// ERC20 basic token contract being held
IERC20Upgradeable private _token;
// beneficiary of tokens after they are released
address private _beneficiary;
// timestamp when token release is e... | /**
* @dev A token holder contract that will allow a beneficiary to extract the
* tokens after a given release time.
*
* Useful for simple vesting schedules like "advisors get all of their tokens
* after 1 year".
*/ | NatSpecMultiLine | beneficiary | function beneficiary() public view virtual returns (address) {
return _beneficiary;
}
| /**
* @return the beneficiary of the tokens.
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1194,
1295
]
} | 15,413 | ||
SchnoodleTimelockFactory | @openzeppelin/contracts-upgradeable/token/ERC20/utils/TokenTimelockUpgradeable.sol | 0x8b37893f470e0237e523b1efa0edfbc9dc445cf9 | Solidity | TokenTimelockUpgradeable | contract TokenTimelockUpgradeable is Initializable {
using SafeERC20Upgradeable for IERC20Upgradeable;
// ERC20 basic token contract being held
IERC20Upgradeable private _token;
// beneficiary of tokens after they are released
address private _beneficiary;
// timestamp when token release is e... | /**
* @dev A token holder contract that will allow a beneficiary to extract the
* tokens after a given release time.
*
* Useful for simple vesting schedules like "advisors get all of their tokens
* after 1 year".
*/ | NatSpecMultiLine | releaseTime | function releaseTime() public view virtual returns (uint256) {
return _releaseTime;
}
| /**
* @return the time when the tokens are released.
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1367,
1468
]
} | 15,414 | ||
SchnoodleTimelockFactory | @openzeppelin/contracts-upgradeable/token/ERC20/utils/TokenTimelockUpgradeable.sol | 0x8b37893f470e0237e523b1efa0edfbc9dc445cf9 | Solidity | TokenTimelockUpgradeable | contract TokenTimelockUpgradeable is Initializable {
using SafeERC20Upgradeable for IERC20Upgradeable;
// ERC20 basic token contract being held
IERC20Upgradeable private _token;
// beneficiary of tokens after they are released
address private _beneficiary;
// timestamp when token release is e... | /**
* @dev A token holder contract that will allow a beneficiary to extract the
* tokens after a given release time.
*
* Useful for simple vesting schedules like "advisors get all of their tokens
* after 1 year".
*/ | NatSpecMultiLine | release | function release() public virtual {
require(block.timestamp >= releaseTime(), "TokenTimelock: current time is before release time");
uint256 amount = token().balanceOf(address(this));
require(amount > 0, "TokenTimelock: no tokens to release");
token().safeTransfer(beneficiary(), amount);
}
| /**
* @notice Transfers tokens held by timelock to beneficiary.
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1551,
1883
]
} | 15,415 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the... | /**
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
756,
953
]
} | 15,416 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1049,
1178
]
} | 15,417 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | 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;
}
/**
* ... | /**
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
95,
302
]
} | 15,418 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | 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;
}
/**
* ... | /**
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
392,
692
]
} | 15,419 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | 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;
}
/**
* ... | /**
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
812,
940
]
} | 15,420 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | 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;
}
/**
* ... | /**
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1010,
1156
]
} | 15,421 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | 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_;
}
/**
... | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
211,
307
]
} | 15,422 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | 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_;
}
/**
... | 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 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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
475,
835
]
} | 15,423 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | 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_;
}
/**
... | 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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1051,
1163
]
} | 15,424 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @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);
... | /**
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
410,
903
]
} | 15,425 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1546,
1757
]
} | 15,426 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
2088,
2227
]
} | 15,427 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
2704,
2989
]
} | 15,428 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @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);
}
... | /**
* @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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
3471,
3922
]
} | 15,429 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @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 | approveAndCall | function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
| /**
* Token owner can approve for `spender` to transferFrom(...) `tokens`
* from the token owner's account. The `spender` contract function
* `receiveApproval(...)` is then executed
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
4143,
4481
]
} | 15,430 |
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | MintableToken | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param... | mint | function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
| /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
508,
815
]
} | 15,431 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | MintableToken | contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param... | finishMinting | function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
| /**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
937,
1100
]
} | 15,432 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | CappedToken | contract CappedToken is MintableToken {
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of token... | mint | function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
| /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
413,
604
]
} | 15,433 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Mod... | pause | function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
| /**
* @dev called by the owner to pause, triggers stopped state
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
555,
663
]
} | 15,434 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Mod... | unpause | function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
| /**
* @dev called by the owner to unpause, returns to normal state
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
751,
861
]
} | 15,435 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | PausableToken | contract PausableToken is StandardToken, Pausable {
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
return su... | batchTransfer | function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
uint cnt = _receivers.length;
uint256 amount = uint256(cnt).mul(_value);
require(cnt > 0 && cnt <= 500);
require(_value > 0 && balances[msg.sender] >= amount);... | /**
* @dev Function to batch send tokens
* @param _receivers The addresses that will receive the tokens.
* @param _value The amount of tokens to send.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1362,
2045
]
} | 15,436 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | PausableToken | contract PausableToken is StandardToken, Pausable {
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
return su... | batchTransferValues | function batchTransferValues(address[] _receivers, uint256[] _values) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
uint cnt = _receivers.length;
require(cnt == _values.length);
require(cnt > 0 && cnt <= 500);
uint256 amount = 0;
for (uint i = 0; i < ... | /**
* @dev Function to batch send tokens
* @param _receivers The addresses that will receive the tokens.
* @param _values The array of amount to send.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
2231,
3094
]
} | 15,437 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | PausableToken | contract PausableToken is StandardToken, Pausable {
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
return su... | batchFreeze | function batchFreeze(address[] _addresses, bool _freeze) onlyOwner public {
for (uint i = 0; i < _addresses.length; i++) {
frozenAccount[_addresses[i]] = _freeze;
emit FrozenFunds(_addresses[i], _freeze);
}
}
| /**
* @dev Function to batch freeze accounts
* @param _addresses The addresses that will be frozen/unfrozen.
* @param _freeze To freeze or not.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
3271,
3533
]
} | 15,438 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | TravelToken | contract TravelToken is CappedToken, PausableToken {
string public constant name = "Travel Chain 旅游链";
string public constant symbol = "Travel";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = (10*10000*10000 - 1) * (10 ** uint256(decimals));
uint256 public const... | mint | function mint(address _to, uint256 _amount) onlyOwner canMint whenNotPaused public returns (bool) {
return super.mint(_to, _amount);
}
| /**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
894,
1047
]
} | 15,439 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | TravelToken | contract TravelToken is CappedToken, PausableToken {
string public constant name = "Travel Chain 旅游链";
string public constant symbol = "Travel";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = (10*10000*10000 - 1) * (10 ** uint256(decimals));
uint256 public const... | finishMinting | function finishMinting() onlyOwner canMint whenNotPaused public returns (bool) {
return super.finishMinting();
}
| /**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1169,
1300
]
} | 15,440 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | TravelToken | contract TravelToken is CappedToken, PausableToken {
string public constant name = "Travel Chain 旅游链";
string public constant symbol = "Travel";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = (10*10000*10000 - 1) * (10 ** uint256(decimals));
uint256 public const... | transferOwnership | function transferOwnership(address newOwner) onlyOwner whenNotPaused public {
super.transferOwnership(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.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1469,
1602
]
} | 15,441 | ||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | TravelToken | contract TravelToken is CappedToken, PausableToken {
string public constant name = "Travel Chain 旅游链";
string public constant symbol = "Travel";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = (10*10000*10000 - 1) * (10 ** uint256(decimals));
uint256 public const... | function() payable public {
revert();
}
| /**
* The fallback function.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1652,
1710
]
} | 15,442 | |||
TravelToken | TravelToken.sol | 0xc72b15684922d3bc090c3d3426e979c7ab2588b4 | Solidity | TravelToken | contract TravelToken is CappedToken, PausableToken {
string public constant name = "Travel Chain 旅游链";
string public constant symbol = "Travel";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = (10*10000*10000 - 1) * (10 ** uint256(decimals));
uint256 public const... | transferAnyERC20Token | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20(tokenAddress).transfer(owner, tokens);
}
| /**
* Owner can transfer out any accidentally sent ERC20 tokens
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | None | bzzr://e0f73953f244d358224bd0dea260e05c3e31d0923e12f862a771044aa41d9df0 | {
"func_code_index": [
1799,
1979
]
} | 15,443 | ||
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
259,
445
]
} | 15,444 |
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
723,
864
]
} | 15,445 |
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
1162,
1359
]
} | 15,446 |
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
1613,
2089
]
} | 15,447 |
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
2560,
2697
]
} | 15,448 |
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
3188,
3471
]
} | 15,449 |
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
3931,
4066
]
} | 15,450 |
PnxToken | contracts/SafeMath.sol | 0xbdd50c7b6c871d9afb278445d5b74fdc4705a234 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.5.16+commit.9c3226ce | MIT | bzzr://a20da6890d9ba41cbd8700bb714e6b3631f605e885edca18caf97c9ffe487c5d | {
"func_code_index": [
4546,
4717
]
} | 15,451 |
MasterChef | /Volumes/Data/Projects/Less/lessswap-contracts/contracts/libraries/Ownable.sol | 0x0cab43bd1f6f34220feed5bdc72dd0b09c5701a1 | Solidity | Ownable | contract Ownable {
address public owner;
address public pendingOwner;
event LogOwnerShipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event LogOwnerShipTransferInitiated(
address indexed previousOwner,
address indexed newOwner
);
/*... | /**
* @title Owned
* @dev Basic contract for authorization control.
* @author dicether
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address _newOwner) public onlyOwner {
pendingOwner = _newOwner;
emit LogOwnerShipTransferInitiated(owner, _newOwner);
}
| /**
* @dev Allows the current owner to set the pendingOwner address.
* @param _newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
993,
1163
]
} | 15,452 | ||
MasterChef | /Volumes/Data/Projects/Less/lessswap-contracts/contracts/libraries/Ownable.sol | 0x0cab43bd1f6f34220feed5bdc72dd0b09c5701a1 | Solidity | Ownable | contract Ownable {
address public owner;
address public pendingOwner;
event LogOwnerShipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event LogOwnerShipTransferInitiated(
address indexed previousOwner,
address indexed newOwner
);
/*... | /**
* @title Owned
* @dev Basic contract for authorization control.
* @author dicether
*/ | NatSpecMultiLine | claimOwnership | function claimOwnership() public onlyPendingOwner {
owner = pendingOwner;
pendingOwner = address(0);
emit LogOwnerShipTransferred(owner, pendingOwner);
}
| /**
* @dev PendingOwner can accept ownership.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
1228,
1413
]
} | 15,453 | ||
SuperBowlinu | SuperBowlinu.sol | 0x2dd190a452fcfcf831a691c5d697cf24c8f3a8da | Solidity | SuperBowlinu | contract SuperBowlinu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "SuperBowl Inu";
string private constant _symbol = "SuperBowl Inu";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address =... | setMinSwapTokensThreshold | function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwnes {
_swapTokensAtAmount = swapTokensAtAmount;
}
| //Set minimum tokens required to swap. | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc45a8c666d383e4474363a4b353f86222c230b492fe5492f8de469bb88a0f71 | {
"func_code_index": [
13519,
13663
]
} | 15,454 | ||
SuperBowlinu | SuperBowlinu.sol | 0x2dd190a452fcfcf831a691c5d697cf24c8f3a8da | Solidity | SuperBowlinu | contract SuperBowlinu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "SuperBowl Inu";
string private constant _symbol = "SuperBowl Inu";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address =... | toggleSwap | function toggleSwap(bool _swapEnabled) public onlyOwner {
swapEnabled = _swapEnabled;
}
| //Set minimum tokens required to swap. | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc45a8c666d383e4474363a4b353f86222c230b492fe5492f8de469bb88a0f71 | {
"func_code_index": [
13714,
13820
]
} | 15,455 | ||
SuperBowlinu | SuperBowlinu.sol | 0x2dd190a452fcfcf831a691c5d697cf24c8f3a8da | Solidity | SuperBowlinu | contract SuperBowlinu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "SuperBowl Inu";
string private constant _symbol = "SuperBowl Inu";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address =... | setMaxTxnAmount | function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
_maxTxAmount = maxTxAmount;
}
| //Set Max transaction | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc45a8c666d383e4474363a4b353f86222c230b492fe5492f8de469bb88a0f71 | {
"func_code_index": [
13854,
13967
]
} | 15,456 | ||
MasterChef | /Volumes/Data/Projects/Less/lessswap-contracts/contracts/libraries/SafeERC20.sol | 0x0cab43bd1f6f34220feed5bdc72dd0b09c5701a1 | Solidity | SafeERC20 | library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(
token,
abi.encodeWithSelector(token.transfer.selector, to, value)
)... | /**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using ... | NatSpecMultiLine | safeApprove | function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-... | /**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
864,
1558
]
} | 15,457 | ||
MasterChef | /Volumes/Data/Projects/Less/lessswap-contracts/contracts/libraries/SafeERC20.sol | 0x0cab43bd1f6f34220feed5bdc72dd0b09c5701a1 | Solidity | SafeERC20 | library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(
token,
abi.encodeWithSelector(token.transfer.selector, to, value)
)... | /**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using ... | NatSpecMultiLine | _callOptionalReturn | function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target addre... | /**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.enc... | NatSpecMultiLine | v0.6.12+commit.27d51765 | {
"func_code_index": [
2868,
3715
]
} | 15,458 | ||
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | totalSupply | function totalSupply() constant returns (uint256 supply) {}
| /// @return total amount of tokens | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
60,
124
]
} | 15,459 | |||
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | balanceOf | function balanceOf(address _owner) constant returns (uint256 balance) {}
| /// @param _owner The address from which the balance will be retrieved
/// @return The balance | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
232,
309
]
} | 15,460 | |||
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transfer | function transfer(address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
546,
623
]
} | 15,461 | |||
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
946,
1042
]
} | 15,462 | |||
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | approve | function approve(address _spender, uint256 _value) returns (bool success) {}
| /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
1326,
1407
]
} | 15,463 | |||
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | allowance | function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
| /// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent | NatSpecSingleLine | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
1615,
1712
]
} | 15,464 | |||
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | STR | contract STR is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise t... | //name this contract whatever you'd like | LineComment | STR | function STR(
) {
balances[msg.sender] = 326226226;
totalSupply = 326226226;
name = "STREAMING"; // Set the name for display purposes
decimals = 0; // Amount of decimals for display purposes
symbol = "STR"; ... | //human 0.1 standard. Just an arbitrary versioning scheme. | LineComment | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
914,
1316
]
} | 15,465 | |
STR | STR.sol | 0x6c49802f7a55e22c2cd689c97b9ee6341d73d153 | Solidity | STR | contract STR is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise t... | //name this contract whatever you'd like | LineComment | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually s... | /* Approves and then calls the receiving contract */ | Comment | v0.4.21+commit.dfe3193c | bzzr://008fe317d8eed67a60d37f3d5fa0d86fff424cb95c14a95349ee146b95936bf0 | {
"func_code_index": [
1377,
2182
]
} | 15,466 | |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipien... | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
163,
236
]
} | 15,467 | ||
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipien... | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
460,
560
]
} | 15,468 | ||
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipien... | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
839,
954
]
} | 15,469 | ||
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipien... | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
1618,
1697
]
} | 15,470 | ||
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | IERC20 | interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipien... | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
2010,
2146
]
} | 15,471 | ||
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
259,
445
]
} | 15,472 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
723,
864
]
} | 15,473 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
1162,
1393
]
} | 15,474 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
1647,
2123
]
} | 15,475 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
2594,
2731
]
} | 15,476 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
3222,
3539
]
} | 15,477 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
3999,
4134
]
} | 15,478 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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 ... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
4614,
4819
]
} | 15,479 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | Context | abstract contract Context {
//function _msgSender() internal view virtual returns (address payable) {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mut... | _msgSender | function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
| //function _msgSender() internal view virtual returns (address payable) { | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
108,
211
]
} | 15,480 | ||
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
606,
1252
]
} | 15,481 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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}("");
re... | /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `tr... | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
2182,
2656
]
} | 15,482 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
3412,
3615
]
} | 15,483 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
3840,
4075
]
} | 15,484 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
4445,
4806
]
} | 15,485 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | 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... | /**
* @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.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
5057,
5458
]
} | 15,486 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as th... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
581,
665
]
} | 15,487 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as th... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
1223,
1376
]
} | 15,488 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as th... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
1526,
1812
]
} | 15,489 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as th... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | lock | function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
| //Locks the contract for owner for the amount of time provided | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
1980,
2211
]
} | 15,490 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as th... | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
... | NatSpecMultiLine | unlock | function unlock() public virtual {
require(
_previousOwner == msg.sender,
"You don't have permission to unlock"
);
require(block.timestamp > _lockTime, "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
| //Unlocks the contract for owner when _lockTime is exceeds | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
2278,
2624
]
} | 15,491 |
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | WGMINU | contract WGMINU is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) p... | //to recieve ETH from uniswapV2Router when swaping | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
9620,
9654
]
} | 15,492 | ||||
WGMINU | WGMINU.sol | 0x04703d8ea711a35091051c5b812a1851d69a0f26 | Solidity | WGMINU | contract WGMINU is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) p... | _tokenTransfer | function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
if (!canTrade) {
require(sender == owner()); // only owner allowed to trade or add liquidity
}
if (!takeFee) removeAllFee();
if (_isExcluded[sender] && !_isExclude... | //this method is responsible for taking all fee, if takeFee is true | LineComment | v0.8.9+commit.e5eed63a | None | ipfs://bc1d7a0b01c733850a567703b1d9efe75c6348de475df2c628a96d2a07054580 | {
"func_code_index": [
18113,
19086
]
} | 15,493 | ||
ORACLESWAP | ORACLESWAP.sol | 0x6b57d9156e43bd2ed5ccb2e2a774d651b0f3e9fc | 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 Moves ... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://35d0810198accbe7f371126ad3eaf3a436bd9e6af927293e08d942e8abea464b | {
"func_code_index": [
88,
146
]
} | 15,494 |
ORACLESWAP | ORACLESWAP.sol | 0x6b57d9156e43bd2ed5ccb2e2a774d651b0f3e9fc | 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 Moves ... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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 | MIT | ipfs://35d0810198accbe7f371126ad3eaf3a436bd9e6af927293e08d942e8abea464b | {
"func_code_index": [
223,
294
]
} | 15,495 |
ORACLESWAP | ORACLESWAP.sol | 0x6b57d9156e43bd2ed5ccb2e2a774d651b0f3e9fc | 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 Moves ... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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 | MIT | ipfs://35d0810198accbe7f371126ad3eaf3a436bd9e6af927293e08d942e8abea464b | {
"func_code_index": [
504,
584
]
} | 15,496 |
ORACLESWAP | ORACLESWAP.sol | 0x6b57d9156e43bd2ed5ccb2e2a774d651b0f3e9fc | 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 Moves ... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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 | MIT | ipfs://35d0810198accbe7f371126ad3eaf3a436bd9e6af927293e08d942e8abea464b | {
"func_code_index": [
849,
935
]
} | 15,497 |
ORACLESWAP | ORACLESWAP.sol | 0x6b57d9156e43bd2ed5ccb2e2a774d651b0f3e9fc | 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 Moves ... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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 | MIT | ipfs://35d0810198accbe7f371126ad3eaf3a436bd9e6af927293e08d942e8abea464b | {
"func_code_index": [
1571,
1648
]
} | 15,498 |
ORACLESWAP | ORACLESWAP.sol | 0x6b57d9156e43bd2ed5ccb2e2a774d651b0f3e9fc | 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 Moves ... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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 | MIT | ipfs://35d0810198accbe7f371126ad3eaf3a436bd9e6af927293e08d942e8abea464b | {
"func_code_index": [
1943,
2043
]
} | 15,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.