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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
BlueSparrow | SafeMath.sol | 0x4d67edef87a5ff910954899f4e5a0aaf107afd42 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | None | ipfs://b3d6256c48fe6fcc106aca14bf66c21769c212a76d65e8310f9e605aefa1789e | {
"func_code_index": [
3188,
3471
]
} | 23,700 | ||
BlueSparrow | SafeMath.sol | 0x4d67edef87a5ff910954899f4e5a0aaf107afd42 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | None | ipfs://b3d6256c48fe6fcc106aca14bf66c21769c212a76d65e8310f9e605aefa1789e | {
"func_code_index": [
3931,
4066
]
} | 23,701 | ||
BlueSparrow | SafeMath.sol | 0x4d67edef87a5ff910954899f4e5a0aaf107afd42 | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns ... | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | None | ipfs://b3d6256c48fe6fcc106aca14bf66c21769c212a76d65e8310f9e605aefa1789e | {
"func_code_index": [
4546,
4717
]
} | 23,702 | ||
IncompleteControlPowah | contracts/IncompleteControlPowah.sol | 0xcf88f5bf04184d4e24d9b6bc462b6f3c04c6eba5 | Solidity | IncompleteControlPowah | contract IncompleteControlPowah is IERC20, IERC20Metadata, Ownable {
uint256 public abRangeMin;
uint256 public abRangeMax;
address public abAddress;
/**
* @param _min min Artblocks Range
* @param _max max ArtBlocks Range
* @param _address ArtBlocks SC address
*/
constructor(
... | /**
* @title IncompleteControlPowah
* @author DefiJesus
*
* An ERC20 token used for tracking the ownership count of incomplete control pieces.
* This contract is inspired by SetProtocol's IndexPowah contract and
* Sushiswap's SUSHIPOWAH contract which serves the same purpose.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _account) public view override returns (uint256) {
uint256[] memory blocks = ArtBlocks(abAddress).tokensOfOwner(_account);
uint256 counter = 0;
for (uint256 i=0; i < blocks.length; i++) {
if (blocks[i] >= abRangeMin && blocks[i] <= abRangeMax) {
counter++;
... | /**
* Computes an address's balance of incomplete control pieces.
*
* Balances can not be transfered in the traditional way, but are instead
* computed by the amount of ArtBlocks tokens that an account directly
* holds.
*
* @param _account the address of the owner
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
1136,
1533
]
} | 23,703 | ||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | wallet | function wallet() external view returns (address);
| /// @return Address of account that starts and stops vesting for different parties | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
971,
1025
]
} | 23,704 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | token | function token() external view returns (IERC20);
| /// @return Address of token that is being vested | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1081,
1133
]
} | 23,705 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | getVestingTerms | function getVestingTerms(address receiver) external view returns (VestingTerms memory);
| /// @dev Returns terms on which particular reciever is getting vested tokens
/// @param receiver Address of beneficiary
/// @return Vesting terms of particular receiver | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1316,
1407
]
} | 23,706 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | startVesting | function startVesting(address receiver, VestingTerms calldata terms) external;
| /// @dev Adds new account for vesting
/// @param receiver Beneficiary for vesting tokens
/// @param terms Vesting terms for particular receiver | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1565,
1647
]
} | 23,707 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | startVestingBatch | function startVestingBatch(address[] calldata receivers, VestingTerms[] calldata terms) external;
| /// @dev Adds multiple accounts for vesting
/// Arrays need to be of same length
/// @param receivers Beneficiaries for vesting tokens
/// @param terms Vesting terms for all accounts | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
1848,
1949
]
} | 23,708 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | claim | function claim() external;
| /// @dev Transfers all vested tokens to the sender | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
2006,
2036
]
} | 23,709 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | claim | function claim(uint256 value) external;
| /// @dev Transfers a part of vested tokens to the sender
/// @param value Number of tokens to claim
/// The special value type(uint256).max will try to claim all available tokens | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
2242,
2285
]
} | 23,710 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | transferVesting | function transferVesting(address oldAddress, address newAddress) external;
| /// @dev Transfers vesting schedule from `msg.sender` to new address
/// A receiver cannot have an existing vesting schedule.
/// @param oldAddress Address for current token receiver
/// @param newAddress Address for new token receiver | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
2539,
2617
]
} | 23,711 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | stopVesting | function stopVesting(address receiver) external;
| /// @dev Stops vesting for receiver and sends unvested tokens back to wallet
/// Any earned claimable amount is still claimable through `claim()`.
/// Note that the account cannot be used again as the vesting receiver.
/// @param receiver Address of account for which we are stopping vesting | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
2927,
2979
]
} | 23,712 | ||||
ERC20Vesting | contracts/token/vesting/IERC20Vesting.sol | 0xca65e71ee7fb8e85ede0e7ef30f029efa8fe4a08 | Solidity | IERC20Vesting | interface IERC20Vesting {
/// @dev Vesting Terms for ERC tokens
struct VestingTerms {
/// @dev startTime for vesting
uint256 startTime;
/// @dev vesting Period
uint256 period;
/// @dev total amount of tokens to vest over period
uint256 amount;
/// @dev how... | claimable | function claimable(address receiver) external view returns (uint);
| /// @dev Calculates the maximum amount of vested tokens that can be claimed for particular address
/// @param receiver Address of token receiver
/// @return Number of vested tokens one can claim | NatSpecSingleLine | v0.8.6+commit.11564f7e | {
"func_code_index": [
3188,
3258
]
} | 23,713 | ||||
nftCryptoGems | @openzeppelin/contracts/access/Ownable.sol | 0x44cc59bde0dea5f928bc25c71a3191a0693670aa | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
... | /**
* @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 virtual returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://b62ec4a057760cf02cabcb6c7ef003900b3b219426b70a0d5ccab69b1f961b23 | {
"func_code_index": [
402,
494
]
} | 23,714 |
nftCryptoGems | @openzeppelin/contracts/access/Ownable.sol | 0x44cc59bde0dea5f928bc25c71a3191a0693670aa | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
... | /**
* @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 {
_setOwner(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.7+commit.e28d00a7 | MIT | ipfs://b62ec4a057760cf02cabcb6c7ef003900b3b219426b70a0d5ccab69b1f961b23 | {
"func_code_index": [
1055,
1154
]
} | 23,715 |
nftCryptoGems | @openzeppelin/contracts/access/Ownable.sol | 0x44cc59bde0dea5f928bc25c71a3191a0693670aa | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
... | /**
* @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");
_setOwner(newOwner);
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | MIT | ipfs://b62ec4a057760cf02cabcb6c7ef003900b3b219426b70a0d5ccab69b1f961b23 | {
"func_code_index": [
1305,
1502
]
} | 23,716 |
nftCryptoGems | @openzeppelin/contracts/access/Ownable.sol | 0x44cc59bde0dea5f928bc25c71a3191a0693670aa | Solidity | nftCryptoGems | contract nftCryptoGems is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.0777 ether; // a changer pour le mainet
uint256 public maxSupply = 777; // a changer pour le mainet
uint256 public maxMintAmount = 7; ... | reveal | function reveal() public onlyOwner() {
revealed = true;
}
| //only owner | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://b62ec4a057760cf02cabcb6c7ef003900b3b219426b70a0d5ccab69b1f961b23 | {
"func_code_index": [
5119,
5189
]
} | 23,717 | ||
nftCryptoGems | @openzeppelin/contracts/access/Ownable.sol | 0x44cc59bde0dea5f928bc25c71a3191a0693670aa | Solidity | nftCryptoGems | contract nftCryptoGems is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.0777 ether; // a changer pour le mainet
uint256 public maxSupply = 777; // a changer pour le mainet
uint256 public maxMintAmount = 7; ... | withdraw | function withdraw() public payable onlyOwner {
uint256 supply = totalSupply();
require(supply == maxSupply || block.timestamp >= headStart, "Can not withdraw yet.");
require(address(this).balance > 1 ether);
uint256 poolBalance = address(this).balance * 20 / 100;
uint256 bankBalance = address(this).balance ... | // minting rewards bonus for people who help. | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://b62ec4a057760cf02cabcb6c7ef003900b3b219426b70a0d5ccab69b1f961b23 | {
"func_code_index": [
5952,
7347
]
} | 23,718 | ||
FLOW | contracts\math\ABDKMath.sol | 0xc6e64729931f60d2c8bc70a27d66d9e0c28d1bf9 | Solidity | ABDKMath64x64 | library ABDKMath64x64 {
/**
* Minimum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
/**
* Maximum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFF... | /**
* Smart contract library of mathematical functions operating with signed
* 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is
* basically a simple fraction whose numerator is signed 128-bit integer and
* denominator is 2^64. As long as denominator is always the same, there is no
* nee... | NatSpecMultiLine | add | function add (int128 x, int128 y) internal pure returns (int128) {
int256 result = int256(x) + y;
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
| /**
* Calculate x + y. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/ | NatSpecMultiLine | v0.6.2+commit.bacdbe57 | None | ipfs://fd1feee2443660dcf06f9c88a2a78dd5fa53d2869e8f6d40070dd42563a8029a | {
"func_code_index": [
556,
754
]
} | 23,719 |
FLOW | contracts\math\ABDKMath.sol | 0xc6e64729931f60d2c8bc70a27d66d9e0c28d1bf9 | Solidity | ABDKMath64x64 | library ABDKMath64x64 {
/**
* Minimum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
/**
* Maximum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFF... | /**
* Smart contract library of mathematical functions operating with signed
* 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is
* basically a simple fraction whose numerator is signed 128-bit integer and
* denominator is 2^64. As long as denominator is always the same, there is no
* nee... | NatSpecMultiLine | mulu | function mulu (int128 x, uint256 y) internal pure returns (uint256) {
if (y == 0) return 0;
require (x >= 0);
uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
uint256 hi = uint256 (x) * (y >> 128);
require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
hi... | /**
* Calculate x * y rounding down, where x is signed 64.64 fixed point number
* and y is unsigned 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64 fixed point number
* @param y unsigned 256-bit integer number
* @return unsigned 256-bit integer number
*/ | NatSpecMultiLine | v0.6.2+commit.bacdbe57 | None | ipfs://fd1feee2443660dcf06f9c88a2a78dd5fa53d2869e8f6d40070dd42563a8029a | {
"func_code_index": [
1066,
1538
]
} | 23,720 |
FLOW | contracts\math\ABDKMath.sol | 0xc6e64729931f60d2c8bc70a27d66d9e0c28d1bf9 | Solidity | ABDKMath64x64 | library ABDKMath64x64 {
/**
* Minimum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
/**
* Maximum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFF... | /**
* Smart contract library of mathematical functions operating with signed
* 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is
* basically a simple fraction whose numerator is signed 128-bit integer and
* denominator is 2^64. As long as denominator is always the same, there is no
* nee... | NatSpecMultiLine | pow | function pow (int128 x, uint256 y) internal pure returns (int128) {
uint256 absoluteResult;
bool negativeResult = false;
if (x >= 0) {
absoluteResult = powu (uint256 (x) << 63, y);
} else {
// We rely on overflow behavior here
absoluteResult = powu (uint256 (uint128 (-x)) << 63, y);
nega... | /**
* Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
* and y is unsigned 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y uint256 value
* @return signed 64.64-bit fixed point number
*/ | NatSpecMultiLine | v0.6.2+commit.bacdbe57 | None | ipfs://fd1feee2443660dcf06f9c88a2a78dd5fa53d2869e8f6d40070dd42563a8029a | {
"func_code_index": [
1842,
2591
]
} | 23,721 |
FLOW | contracts\math\ABDKMath.sol | 0xc6e64729931f60d2c8bc70a27d66d9e0c28d1bf9 | Solidity | ABDKMath64x64 | library ABDKMath64x64 {
/**
* Minimum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
/**
* Maximum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFF... | /**
* Smart contract library of mathematical functions operating with signed
* 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is
* basically a simple fraction whose numerator is signed 128-bit integer and
* denominator is 2^64. As long as denominator is always the same, there is no
* nee... | NatSpecMultiLine | powu | function powu (uint256 x, uint256 y) private pure returns (uint256) {
if (y == 0) return 0x80000000000000000000000000000000;
else if (x == 0) return 0;
else {
int256 msb = 0;
uint256 xc = x;
if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; }
if (xc >= 0x1000000000000... | /**
* Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point
* number and y is unsigned 256-bit integer number. Revert on overflow.
*
* @param x unsigned 129.127-bit fixed point number
* @param y uint256 value
* @return unsigned 129.127-bit fixed point number
*/ | NatSpecMultiLine | v0.6.2+commit.bacdbe57 | None | ipfs://fd1feee2443660dcf06f9c88a2a78dd5fa53d2869e8f6d40070dd42563a8029a | {
"func_code_index": [
2907,
4647
]
} | 23,722 |
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
251,
437
]
} | 23,723 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
707,
848
]
} | 23,724 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
1180,
1377
]
} | 23,725 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
1623,
2099
]
} | 23,726 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
2562,
2699
]
} | 23,727 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
... | /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
3224,
3574
]
} | 23,728 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
4026,
4161
]
} | 23,729 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
4675,
4846
]
} | 23,730 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | Context | contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (addres... | _msgSender | function _msgSender() internal view returns (address payable) {
return msg.sender;
}
| // solhint-disable-previous-line no-empty-blocks | LineComment | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
265,
368
]
} | 23,731 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSup... | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
299,
395
]
} | 23,732 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | ERC20 | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSup... | _mint | function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
| /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
2571,
2884
]
} | 23,733 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
* these values are immutable: they can only be set once during
* construction.
*/
con... | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
550,
638
]
} | 23,734 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
* these values are immutable: they can only be set once during
* construction.
*/
con... | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
752,
844
]
} | 23,735 | ||
GUMA | GUMA.sol | 0x1e9e699f4a7e83f0fe984cf88c20e8325e99e85c | Solidity | ERC20Detailed | contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
* these values are immutable: they can only be set once during
* construction.
*/
con... | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei.
*
*... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://00bae62adf8db38b81c7b2f9dd0f85ddc291d897eb3bf75adeefc58dae21a245 | {
"func_code_index": [
1402,
1490
]
} | 23,736 | ||
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | /**
* @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.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
497,
581
]
} | 23,737 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | /**
* @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.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
1139,
1292
]
} | 23,738 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSend... | /**
* @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.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
1442,
1691
]
} | 23,739 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
251,
437
]
} | 23,740 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
707,
848
]
} | 23,741 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
1138,
1335
]
} | 23,742 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
... | /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
1581,
2057
]
} | 23,743 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
| /**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to reve... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
2520,
2657
]
} | 23,744 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
... | /**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an in... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
3140,
3490
]
} | 23,745 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consumi... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
3942,
4077
]
} | 23,746 |
TokenLockWithRelease | TokenLockWithRelease.sol | 0x2a997ead7478885a66e6961ac0837800a07492fc | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256... | /**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming la... | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcod... | NatSpecMultiLine | v0.6.12+commit.27d51765 | None | ipfs://0449b8de2d65f6d6d4d9b8fcc1eb65565461796431d378c6dc768aad1f517e1b | {
"func_code_index": [
4549,
4720
]
} | 23,747 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() external view returns (uint256);
| /**
* @dev Returns the amount of tokens in existence.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
94,
154
]
} | 23,748 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account) external view returns (uint256);
| /**
* @dev Returns the amount of tokens owned by `account`.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
237,
310
]
} | 23,749 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
534,
616
]
} | 23,750 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
895,
983
]
} | 23,751 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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.
*
* Emits an {Approval} event.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1218,
1297
]
} | 23,752 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | IERC20 | interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1610,
1712
]
} | 23,753 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
259,
445
]
} | 23,754 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
723,
864
]
} | 23,755 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1162,
1359
]
} | 23,756 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
| /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1613,
1870
]
} | 23,757 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
2341,
2478
]
} | 23,758 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
2969,
3172
]
} | 23,759 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
3632,
3767
]
} | 23,760 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | 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.
*/ | 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.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
4247,
4418
]
} | 23,761 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
*/
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | isContract | function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
| /**
* @dev Returns true if `account` is a contract.
*
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
99,
337
]
} | 23,762 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
*/
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | sendValue | function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address... | /**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
507,
909
]
} | 23,763 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
*/
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return ... | /**
* @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.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1106,
1284
]
} | 23,764 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
*/
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return ... | /**
* @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.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1469,
1670
]
} | 23,765 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
*/
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return ... | /**
* @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`.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1827,
2058
]
} | 23,766 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
*/
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return ... | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | functionCallWithValue | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
| /**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
2269,
2590
]
} | 23,767 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | name | function name() public view returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1095,
1183
]
} | 23,768 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | symbol | function symbol() public view returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1297,
1389
]
} | 23,769 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | decimals | function decimals() public view returns (uint8) {
return _decimals;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1491,
1579
]
} | 23,770 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1639,
1744
]
} | 23,771 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1802,
1926
]
} | 23,772 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
1983,
2163
]
} | 23,773 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
2221,
2377
]
} | 23,774 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
2433,
2607
]
} | 23,775 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ECLR: cannot transfer more than available balance"));
return true;
}
| /**
* @dev See {IERC20-transferFrom}.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
2668,
3003
]
} | 23,776 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
3108,
3331
]
} | 23,777 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ECLR: cannot decrease beyond zero"));
return true;
}
| /**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
3436,
3706
]
} | 23,778 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | _transfer | function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ECLR: cannot transfer from the burn address");
require(recipient != address(0), "ECLR: cannot transfer to the burn address");
_beforeTokenTransfer(sender, recipient, amount);
_... | /**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
3792,
4347
]
} | 23,779 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | _mint | function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ECLR: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer... | /** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
4465,
4847
]
} | 23,780 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | _approve | function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ECLR: Approver cannot be zero address");
require(spender != address(0), "ECLR: Spender cannot approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner,... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
4951,
5317
]
} | 23,781 |
Eclairs | Eclairs.sol | 0x1783e7a9fd7073ca1479e83971740400b0632c1b | Solidity | Eclairs | contract Eclairs is Context, IERC20 {
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 = "Eclairs";
s... | /**
* @dev Implementation of the {IERC20} interface.
*/ | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
| /**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*/ | NatSpecMultiLine | v0.7.0+commit.9e61f92b | None | ipfs://4385140f9747e0548a4e85ff91d7dd0806985777d0fc7146bf01913c78b488d3 | {
"func_code_index": [
5445,
5542
]
} | 23,782 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
96,
303
]
} | 23,783 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
400,
700
]
} | 23,784 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
827,
955
]
} | 23,785 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
1032,
1178
]
} | 23,786 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender account.
**/
constructor() public {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
**/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
665,
856
]
} | 23,787 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
**/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
**/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| /**
* @dev total number of tokens in existence
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
214,
310
]
} | 23,788 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
**/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
**/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
487,
855
]
} | 23,789 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
**/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
... | /**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
**/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
1080,
1192
]
} | 23,790 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 tr... | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
410,
917
]
} | 23,791 | ||
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 tr... | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
1574,
1785
]
} | 23,792 | ||
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 tr... | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
2126,
2271
]
} | 23,793 | ||
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | 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 tr... | 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 | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
3059,
3514
]
} | 23,794 | ||
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | CrowdsaleToken | contract CrowdsaleToken is StandardToken, Configurable, Ownable {
/**
* @dev enum of current crowd sale state
**/
enum Stages {
none,
icoStart,
icoEnd
}
Stages currentStage;
/**
* @dev constructor of CrowdsaleToken
**/
construc... | /**
* @title CrowdsaleToken
* @dev Contract to preform crowd sale with token
**/ | NatSpecMultiLine | function () public payable {
require(currentStage == Stages.icoStart);
require(msg.value > 0);
require(remainingTokens > 0);
uint256 weiAmount = msg.value; // Calculate tokens to sell
uint256 tokens = weiAmount.mul(basePrice).div(0.1 ether);
uint256 returnWei = 0;
... | /**
* @dev fallback function to send ether to for Crowd sale
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
678,
1855
]
} | 23,795 | |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | CrowdsaleToken | contract CrowdsaleToken is StandardToken, Configurable, Ownable {
/**
* @dev enum of current crowd sale state
**/
enum Stages {
none,
icoStart,
icoEnd
}
Stages currentStage;
/**
* @dev constructor of CrowdsaleToken
**/
construc... | /**
* @title CrowdsaleToken
* @dev Contract to preform crowd sale with token
**/ | NatSpecMultiLine | startIco | function startIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
currentStage = Stages.icoStart;
}
| /**
* @dev startIco starts the public ICO
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
1915,
2055
]
} | 23,796 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | CrowdsaleToken | contract CrowdsaleToken is StandardToken, Configurable, Ownable {
/**
* @dev enum of current crowd sale state
**/
enum Stages {
none,
icoStart,
icoEnd
}
Stages currentStage;
/**
* @dev constructor of CrowdsaleToken
**/
construc... | /**
* @title CrowdsaleToken
* @dev Contract to preform crowd sale with token
**/ | NatSpecMultiLine | endIco | function endIco() internal {
currentStage = Stages.icoEnd;
// Transfer any remaining tokens
if(remainingTokens > 0)
balances[owner] = balances[owner].add(remainingTokens);
// transfer any remaining ETH balance in the contract to the owner
owner.transfer(address(this).balance);
}
| /**
* @dev endIco closes down the ICO
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
2112,
2460
]
} | 23,797 |
Bruciare | Bruciare.sol | 0x362998bce7bfc45c1b0a2ecc83952e09712afddb | Solidity | CrowdsaleToken | contract CrowdsaleToken is StandardToken, Configurable, Ownable {
/**
* @dev enum of current crowd sale state
**/
enum Stages {
none,
icoStart,
icoEnd
}
Stages currentStage;
/**
* @dev constructor of CrowdsaleToken
**/
construc... | /**
* @title CrowdsaleToken
* @dev Contract to preform crowd sale with token
**/ | NatSpecMultiLine | finalizeIco | function finalizeIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
endIco();
}
| /**
* @dev finalizeIco closes down the ICO and sets needed varriables
**/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | MIT | bzzr://ca6898e5332d80fd7e23943da979101ab903f1c6dc337cb48649f6d5119852af | {
"func_code_index": [
2548,
2669
]
} | 23,798 |
DivineStats | contracts/DivineStats.sol | 0xf5df2c0201fd06fc5a387cccbd70a1093acb1455 | Solidity | IERC165 | interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function... | /**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/ | NatSpecMultiLine | supportsInterface | function supportsInterface(bytes4 interfaceId) external view returns (bool);
| /**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/ | NatSpecMultiLine | v0.8.0+commit.c7dfd78e | {
"func_code_index": [
365,
445
]
} | 23,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.