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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Creatures | ERC721URIStorage.sol | 0xd227df494367a8b769b4bf2bbebd0388a8758741 | Solidity | ERC721URIStorage | abstract contract ERC721URIStorage is ERC721, Operators {
using Strings for uint256;
// Optional mapping for token URIs
mapping (uint256 => string) private _tokenURIs;
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override r... | /**
* @dev this contract used just for override some
* OpneZeppelin tokenURI() behavior
* so we need redeclare _tokenURIs becouse in OpenZeppelin
* ERC721 it has private visibility
*/ | NatSpecMultiLine | setURISigned | function setURISigned(uint256 tokenId, string calldata _tokenURI, uint8 _v, bytes32 _r, bytes32 _s) external {
require(isValidSignature(tokenId, _tokenURI, _v, _r, _s), "Invalid signature");
_setTokenURI(tokenId, _tokenURI);
}
| /**
* @dev Sets token URI using signature
* This method can be called by anyone, who has signature,
* that was created by signer role
*/ | NatSpecMultiLine | v0.7.4+commit.3f05b770 | MIT | ipfs://308c7d0f38216f626771d86f2b5b3091893bd5f12659a801a1f13db0060ec78f | {
"func_code_index": [
3366,
3620
]
} | 2,907 |
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | totalSupply | function totalSupply() constant returns (uint256 supply) {}
| /// @return total amount of tokens | NatSpecSingleLine | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
60,
124
]
} | 2,908 | |||
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | balanceOf | function balanceOf(address _owner) constant returns (uint256 balance) {}
| /// @param _owner The address from which the balance will be retrieved
/// @return The balance | NatSpecSingleLine | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
232,
309
]
} | 2,909 | |||
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transfer | function transfer(address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
546,
623
]
} | 2,910 | |||
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
| /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not | NatSpecSingleLine | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
946,
1042
]
} | 2,911 | |||
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | approve | function approve(address _spender, uint256 _value) returns (bool success) {}
| /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not | NatSpecSingleLine | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
1326,
1407
]
} | 2,912 | |||
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | Token | contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// ... | allowance | function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
| /// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent | NatSpecSingleLine | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
1615,
1712
]
} | 2,913 | |||
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | NomuraDynamicsCoin | contract NomuraDynamicsCoin is StandardToken { // CHANGE THIS. Update the contract name.
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the c... | NomuraDynamicsCoin | function NomuraDynamicsCoin() {
balances[msg.sender] = 600000000000; //
totalSupply = 600000000000; //
decimals = 0; //
symbol = "NMUR"; //
name = "NomuraDynamicsCoin"; ... | // Where should the raised ETH go?
// This is a constructor function
// which means the following function name has to match the contract name declared above | LineComment | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
1206,
1692
]
} | 2,914 | |||
NomuraDynamicsCoin | NomuraDynamicsCoin.sol | 0x292a3e6c5e875d17460497b52de750cf3072cd39 | Solidity | NomuraDynamicsCoin | contract NomuraDynamicsCoin is StandardToken { // CHANGE THIS. Update the contract name.
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the c... | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually s... | /* Approves and then calls the receiving contract */ | Comment | v0.4.23+commit.124ca40d | bzzr://b6bd7d278ebc62b4345a5288257bedb98fc94726a0a2eeba9dc3f01c5c961842 | {
"func_code_index": [
2316,
3121
]
} | 2,915 | |||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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() {
_transferOwnership(_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.10+commit.fc410830 | {
"func_code_index": [
393,
482
]
} | 2,916 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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() {
_transferOwnership(_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 {
_transferOwnership(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.10+commit.fc410830 | {
"func_code_index": [
1025,
1130
]
} | 2,917 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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() {
_transferOwnership(_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");
_transferOwnership(newOwner);
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1275,
1477
]
} | 2,918 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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() {
_transferOwnership(_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) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1627,
1818
]
} | 2,919 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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);
/**
* @de... | /**
* @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.8.10+commit.fc410830 | {
"func_code_index": [
90,
149
]
} | 2,920 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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);
/**
* @de... | /**
* @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.8.10+commit.fc410830 | {
"func_code_index": [
228,
300
]
} | 2,921 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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);
/**
* @de... | /**
* @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.8.10+commit.fc410830 | {
"func_code_index": [
516,
597
]
} | 2,922 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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);
/**
* @de... | /**
* @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.8.10+commit.fc410830 | {
"func_code_index": [
868,
955
]
} | 2,923 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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);
/**
* @de... | /**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) external returns (bool);
| /**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* tra... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1604,
1682
]
} | 2,924 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | 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);
/**
* @de... | /**
* @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.8.10+commit.fc410830 | {
"func_code_index": [
1985,
2116
]
} | 2,925 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals ... | /**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/ | NatSpecMultiLine | name | function name() external view returns (string memory);
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
96,
154
]
} | 2,926 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals ... | /**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/ | NatSpecMultiLine | symbol | function symbol() external view returns (string memory);
| /**
* @dev Returns the symbol of the token.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
217,
277
]
} | 2,927 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | IERC20Metadata | interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals ... | /**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/ | NatSpecMultiLine | decimals | function decimals() external view returns (uint8);
| /**
* @dev Returns the decimals places of the token.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
349,
403
]
} | 2,928 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | name | function name() public view virtual override returns (string memory) {
return _name;
}
| /**
* @dev Returns the name of the token.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
749,
851
]
} | 2,929 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | symbol | function symbol() public view virtual override returns (string memory) {
return _symbol;
}
| /**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
960,
1066
]
} | 2,930 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | decimals | function decimals() public view virtual override returns (uint8) {
return 18;
}
| /**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the v... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1686,
1781
]
} | 2,931 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | totalSupply | function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
| /**
* @dev See {IERC20-totalSupply}.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1837,
1947
]
} | 2,932 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | balanceOf | function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
| /**
* @dev See {IERC20-balanceOf}.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
2001,
2130
]
} | 2,933 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | transfer | function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
| /**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
2329,
2505
]
} | 2,934 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | allowance | function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
| /**
* @dev See {IERC20-allowance}.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
2559,
2712
]
} | 2,935 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | approve | function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
| /**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
2846,
3016
]
} | 2,936 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | transferFrom | function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance")... | /**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
3479,
3961
]
} | 2,937 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | increaseAllowance | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
| /**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be t... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
4352,
4568
]
} | 2,938 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, curre... | /**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be t... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5051,
5460
]
} | 2,939 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | _transfer | function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint2... | /**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipie... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5930,
6647
]
} | 2,940 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | _mint | function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterToke... | /** @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:
*
* - `account` cannot be the zero address.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
6919,
7312
]
} | 2,941 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | _burn | function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance"... | /**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
7628,
8208
]
} | 2,942 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | _approve | function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spend... | /**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
*... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
8627,
9001
]
} | 2,943 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | _beforeTokenTransfer | function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
| /**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` i... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
9581,
9706
]
} | 2,944 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ERC20 | contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {... | /**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
... | NatSpecMultiLine | _afterTokenTransfer | function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
| /**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to`... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
10290,
10414
]
} | 2,945 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryAdd | function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
| /**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
155,
375
]
} | 2,946 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | trySub | function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
| /**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
517,
710
]
} | 2,947 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryMul | function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// 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
... | /**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
854,
1351
]
} | 2,948 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryDiv | function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
| /**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1496,
1690
]
} | 2,949 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | tryMod | function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
| /**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1845,
2039
]
} | 2,950 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
2270,
2370
]
} | 2,951 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
2637,
2737
]
} | 2,952 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
| /**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
2980,
3080
]
} | 2,953 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
| /**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/ | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
3365,
3465
]
} | 2,954 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting 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 (consuming a... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
3914,
4014
]
} | 2,955 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | sub | function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to ... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
4474,
4709
]
} | 2,956 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | div | function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
| /**
* @dev Returns the integer division of two unsigned integers, reverting 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 invali... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
5189,
5423
]
} | 2,957 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (f... | /**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/ | NatSpecMultiLine | mod | function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
| /**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* C... | NatSpecMultiLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
6065,
6299
]
} | 2,958 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ApeInRecords | contract ApeInRecords is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public d... | /* import {SafeMath} from "lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol"; */ | Comment | enableTrading | function enableTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
lastLpBurnTime = block.timestamp;
}
| // once enabled, can never be turned off | LineComment | v0.8.10+commit.fc410830 | {
"func_code_index": [
4847,
5002
]
} | 2,959 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ApeInRecords | contract ApeInRecords is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public d... | /* import {SafeMath} from "lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol"; */ | Comment | removeLimits | function removeLimits() external onlyOwner returns (bool) {
limitsInEffect = false;
return true;
}
| // remove limits after token is stable | LineComment | v0.8.10+commit.fc410830 | {
"func_code_index": [
5047,
5169
]
} | 2,960 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ApeInRecords | contract ApeInRecords is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public d... | /* import {SafeMath} from "lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol"; */ | Comment | disableTransferDelay | function disableTransferDelay() external onlyOwner returns (bool) {
transferDelayEnabled = false;
return true;
}
| // disable Transfer delay - cannot be reenabled | LineComment | v0.8.10+commit.fc410830 | {
"func_code_index": [
5223,
5359
]
} | 2,961 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ApeInRecords | contract ApeInRecords is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public d... | /* import {SafeMath} from "lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol"; */ | Comment | updateSwapTokensAtAmount | function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(
newAmount <= (totalSupply() * 5) / 1000,
"Swap amount c... | // change the minimum amount of tokens to sell from fees | LineComment | v0.8.10+commit.fc410830 | {
"func_code_index": [
5422,
5908
]
} | 2,962 | ||
ApeInRecords | ApeInRecords.sol | 0xf725f73caee250ae384ec38bb2c77c38ef2cccea | Solidity | ApeInRecords | contract ApeInRecords is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public d... | /* import {SafeMath} from "lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol"; */ | Comment | updateSwapEnabled | function updateSwapEnabled(bool enabled) external onlyOwner {
swapEnabled = enabled;
}
| // only use to disable contract sales if absolutely necessary (emergency use only) | LineComment | v0.8.10+commit.fc410830 | {
"func_code_index": [
6696,
6798
]
} | 2,963 | ||
Vestoria | Vestoria.sol | 0x9363e6eadf5e307b96f26dfd94f355b95a0e2498 | Solidity | SafeMath | library SafeMath {
/**
* 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;
}
/**
* Integ... | /**
* @title SafeMath
*/ | 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;
}
| /**
* Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | bzzr://0be3274577176f1896ad2fde5ade744870a8d9f11485bf3db752f5d22fcec366 | {
"func_code_index": [
90,
297
]
} | 2,964 | |
Vestoria | Vestoria.sol | 0x9363e6eadf5e307b96f26dfd94f355b95a0e2498 | Solidity | SafeMath | library SafeMath {
/**
* 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;
}
/**
* Integ... | /**
* @title SafeMath
*/ | 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;
}
| /**
* Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | bzzr://0be3274577176f1896ad2fde5ade744870a8d9f11485bf3db752f5d22fcec366 | {
"func_code_index": [
382,
682
]
} | 2,965 | |
Vestoria | Vestoria.sol | 0x9363e6eadf5e307b96f26dfd94f355b95a0e2498 | Solidity | SafeMath | library SafeMath {
/**
* 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;
}
/**
* Integ... | /**
* @title SafeMath
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | bzzr://0be3274577176f1896ad2fde5ade744870a8d9f11485bf3db752f5d22fcec366 | {
"func_code_index": [
797,
925
]
} | 2,966 | |
Vestoria | Vestoria.sol | 0x9363e6eadf5e307b96f26dfd94f355b95a0e2498 | Solidity | SafeMath | library SafeMath {
/**
* 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;
}
/**
* Integ... | /**
* @title SafeMath
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.23+commit.124ca40d | bzzr://0be3274577176f1896ad2fde5ade744870a8d9f11485bf3db752f5d22fcec366 | {
"func_code_index": [
990,
1136
]
} | 2,967 | |
BrazuCat | /C/Projects/nft-cat-dapp/contracts/BrazuCat.sol | 0x6925b63cdcae0fff60027f8df0c043a1af90b734 | Solidity | BrazuCat | contract BrazuCat is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI = "https://brazucat.com/";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmbgcNj2ihyDaE2ZSrrkDX8dentd5JVYgy2wuvCMtKJfV8/1.json";
uint256 public cost = 0.03 ether;
uint256... | _baseURI | function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
| // internal | LineComment | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
982,
1087
]
} | 2,968 | ||||
BrazuCat | /C/Projects/nft-cat-dapp/contracts/BrazuCat.sol | 0x6925b63cdcae0fff60027f8df0c043a1af90b734 | Solidity | BrazuCat | contract BrazuCat is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI = "https://brazucat.com/";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmbgcNj2ihyDaE2ZSrrkDX8dentd5JVYgy2wuvCMtKJfV8/1.json";
uint256 public cost = 0.03 ether;
uint256... | mint | function mint(uint256 _mintAmount) public payable {
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply... | // public | LineComment | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
1103,
2168
]
} | 2,969 | ||||
BrazuCat | /C/Projects/nft-cat-dapp/contracts/BrazuCat.sol | 0x6925b63cdcae0fff60027f8df0c043a1af90b734 | Solidity | BrazuCat | contract BrazuCat is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI = "https://brazucat.com/";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmbgcNj2ihyDaE2ZSrrkDX8dentd5JVYgy2wuvCMtKJfV8/1.json";
uint256 public cost = 0.03 ether;
uint256... | reveal | function reveal() public onlyOwner() {
revealed = true;
}
| //only owner | LineComment | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
3291,
3361
]
} | 2,970 | ||||
LandWorks | contracts/interfaces/IDiamondLoupe.sol | 0x678d837fa15eba2b59f6cd5f9f4c580ac2dfc269 | Solidity | IDiamondLoupe | interface IDiamondLoupe {
/// These functions are expected to be called frequently
/// by tools.
struct Facet {
address facetAddress;
bytes4[] functionSelectors;
}
/// @notice Gets all facet addresses and their four byte function selectors.
/// @return facets_ Facet
functio... | // A loupe is a small magnifying glass used to look at diamonds.
// These functions look at diamonds | LineComment | facets | function facets() external view returns (Facet[] memory facets_);
| /// @notice Gets all facet addresses and their four byte function selectors.
/// @return facets_ Facet | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
309,
378
]
} | 2,971 | ||
LandWorks | contracts/interfaces/IDiamondLoupe.sol | 0x678d837fa15eba2b59f6cd5f9f4c580ac2dfc269 | Solidity | IDiamondLoupe | interface IDiamondLoupe {
/// These functions are expected to be called frequently
/// by tools.
struct Facet {
address facetAddress;
bytes4[] functionSelectors;
}
/// @notice Gets all facet addresses and their four byte function selectors.
/// @return facets_ Facet
functio... | // A loupe is a small magnifying glass used to look at diamonds.
// These functions look at diamonds | LineComment | facetFunctionSelectors | function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);
| /// @notice Gets all the function selectors supported by a specific facet.
/// @param _facet The facet address.
/// @return facetFunctionSelectors_ | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
540,
656
]
} | 2,972 | ||
LandWorks | contracts/interfaces/IDiamondLoupe.sol | 0x678d837fa15eba2b59f6cd5f9f4c580ac2dfc269 | Solidity | IDiamondLoupe | interface IDiamondLoupe {
/// These functions are expected to be called frequently
/// by tools.
struct Facet {
address facetAddress;
bytes4[] functionSelectors;
}
/// @notice Gets all facet addresses and their four byte function selectors.
/// @return facets_ Facet
functio... | // A loupe is a small magnifying glass used to look at diamonds.
// These functions look at diamonds | LineComment | facetAddresses | function facetAddresses() external view returns (address[] memory facetAddresses_);
| /// @notice Get all the facet addresses used by a diamond.
/// @return facetAddresses_ | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
753,
840
]
} | 2,973 | ||
LandWorks | contracts/interfaces/IDiamondLoupe.sol | 0x678d837fa15eba2b59f6cd5f9f4c580ac2dfc269 | Solidity | IDiamondLoupe | interface IDiamondLoupe {
/// These functions are expected to be called frequently
/// by tools.
struct Facet {
address facetAddress;
bytes4[] functionSelectors;
}
/// @notice Gets all facet addresses and their four byte function selectors.
/// @return facets_ Facet
functio... | // A loupe is a small magnifying glass used to look at diamonds.
// These functions look at diamonds | LineComment | facetAddress | function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);
| /// @notice Gets the facet that supports the given selector.
/// @dev If facet is not found return address(0).
/// @param _functionSelector The function selector.
/// @return facetAddress_ The facet address. | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1066,
1164
]
} | 2,974 | ||
FishbowlHeads | /contracts/FishbowlHeads.sol | 0x0297669bb8d705a9ec5e34d4a1cbde57348d7cfe | Solidity | FishbowlHeads | contract FishbowlHeads is ERC721Enumerable, Ownable, ReentrancyGuard, IERC777Recipient {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
using Strings for uint256;
uint256 public constant _maxSupply = 9999;
uint256 public constant _maxMintCount = 12;
... | // Function to receive Ether. msg.data must be empty | LineComment | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
10694,
10768
]
} | 2,975 | ||||||
FishbowlHeads | /contracts/FishbowlHeads.sol | 0x0297669bb8d705a9ec5e34d4a1cbde57348d7cfe | Solidity | FishbowlHeads | contract FishbowlHeads is ERC721Enumerable, Ownable, ReentrancyGuard, IERC777Recipient {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
using Strings for uint256;
uint256 public constant _maxSupply = 9999;
uint256 public constant _maxMintCount = 12;
... | // Fallback function is called when msg.data is not empty | LineComment | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
10834,
10920
]
} | 2,976 | ||||||
FishbowlHeads | /contracts/FishbowlHeads.sol | 0x0297669bb8d705a9ec5e34d4a1cbde57348d7cfe | Solidity | FishbowlHeads | contract FishbowlHeads is ERC721Enumerable, Ownable, ReentrancyGuard, IERC777Recipient {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
using Strings for uint256;
uint256 public constant _maxSupply = 9999;
uint256 public constant _maxMintCount = 12;
... | retrieveERC20 | function retrieveERC20(address _tracker, uint256 amount) external onlyOwner {
IERC20(_tracker).transfer(msg.sender, amount);
}
| // --- recovery of tokens sent to this address | LineComment | v0.8.4+commit.c7e474f2 | {
"func_code_index": [
10977,
11122
]
} | 2,977 | ||||
LandWorks | contracts/interfaces/IERC721Consumable.sol | 0x678d837fa15eba2b59f6cd5f9f4c580ac2dfc269 | Solidity | IERC721Consumable | interface IERC721Consumable {
/// @notice Emitted when `owner` changes the `consumer` of an NFT
/// The zero address for consumer indicates that there is no consumer address
/// When a Transfer event emits, this also indicates that the consumer address
/// for that NFT (if any) is set to none
event ... | /// @title ERC-721 Consumer Role extension
/// Note: the ERC-165 identifier for this interface is 0x953c8dfa | NatSpecSingleLine | consumerOf | function consumerOf(uint256 _tokenId) external view returns (address);
| /// @notice Get the consumer address of an NFT
/// @dev The zero address indicates that there is no consumer
/// Throws if `_tokenId` is not a valid NFT
/// @param _tokenId The NFT to get the consumer address for
/// @return The consumer address for this NFT, or the zero address if there is none | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
759,
833
]
} | 2,978 | ||
LandWorks | contracts/interfaces/IERC721Consumable.sol | 0x678d837fa15eba2b59f6cd5f9f4c580ac2dfc269 | Solidity | IERC721Consumable | interface IERC721Consumable {
/// @notice Emitted when `owner` changes the `consumer` of an NFT
/// The zero address for consumer indicates that there is no consumer address
/// When a Transfer event emits, this also indicates that the consumer address
/// for that NFT (if any) is set to none
event ... | /// @title ERC-721 Consumer Role extension
/// Note: the ERC-165 identifier for this interface is 0x953c8dfa | NatSpecSingleLine | changeConsumer | function changeConsumer(address _consumer, uint256 _tokenId) external;
| /// @notice Change or reaffirm the consumer address for an NFT
/// @dev The zero address indicates there is no consumer address
/// Throws unless `msg.sender` is the current NFT owner, an authorised
/// operator of the current owner or approved address
/// Throws if `_tokenId` is not valid NFT
/// @param _consumer The ... | NatSpecSingleLine | v0.8.10+commit.fc410830 | {
"func_code_index": [
1203,
1277
]
} | 2,979 | ||
summitcoin | summitcoin.sol | 0x7aa82ec1cbd3769d2ea55cd3b7957b786d0eff49 | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amoun... | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(balances[msg.sender] >= _value && balances[_to].add(_value) >= balances[_to]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit ... | /**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/ | NatSpecMultiLine | v0.5.8+commit.23d335f2 | None | bzzr://87196933056279919624d66181c5d59b30c4260ded29fd53de2ada9020c06d02 | {
"func_code_index": [
350,
758
]
} | 2,980 | ||
summitcoin | summitcoin.sol | 0x7aa82ec1cbd3769d2ea55cd3b7957b786d0eff49 | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amoun... | balanceOf | function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.5.8+commit.23d335f2 | None | bzzr://87196933056279919624d66181c5d59b30c4260ded29fd53de2ada9020c06d02 | {
"func_code_index": [
974,
1094
]
} | 2,981 | ||
summitcoin | summitcoin.sol | 0x7aa82ec1cbd3769d2ea55cd3b7957b786d0eff49 | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amoun... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_... | /**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.5.8+commit.23d335f2 | None | bzzr://87196933056279919624d66181c5d59b30c4260ded29fd53de2ada9020c06d02 | {
"func_code_index": [
1383,
1833
]
} | 2,982 | ||
summitcoin | summitcoin.sol | 0x7aa82ec1cbd3769d2ea55cd3b7957b786d0eff49 | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amoun... | 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.5.8+commit.23d335f2 | None | bzzr://87196933056279919624d66181c5d59b30c4260ded29fd53de2ada9020c06d02 | {
"func_code_index": [
2476,
2689
]
} | 2,983 | ||
summitcoin | summitcoin.sol | 0x7aa82ec1cbd3769d2ea55cd3b7957b786d0eff49 | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amoun... | allowance | function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.5.8+commit.23d335f2 | None | bzzr://87196933056279919624d66181c5d59b30c4260ded29fd53de2ada9020c06d02 | {
"func_code_index": [
3020,
3169
]
} | 2,984 | ||
summitcoin | summitcoin.sol | 0x7aa82ec1cbd3769d2ea55cd3b7957b786d0eff49 | Solidity | StandardToken | contract StandardToken is Token {
using SafeMath for uint256;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amoun... | increaseApproval | function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| /**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/ | NatSpecMultiLine | v0.5.8+commit.23d335f2 | None | bzzr://87196933056279919624d66181c5d59b30c4260ded29fd53de2ada9020c06d02 | {
"func_code_index": [
3421,
3719
]
} | 2,985 | ||
EctoCrowdsale | openzeppelin-solidity/contracts/crowdsale/validation/WhitelistedCrowdsale.sol | 0x80283ce9f88585ed571d72aa105b8aa56da96821 | Solidity | WhitelistedCrowdsale | contract WhitelistedCrowdsale is Whitelist, Crowdsale {
/**
* @dev Extend parent behavior requiring beneficiary to be in whitelist.
* @param _beneficiary Token beneficiary
* @param _weiAmount Amount of wei contributed
*/
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAm... | /**
* @title WhitelistedCrowdsale
* @dev Crowdsale in which only whitelisted users can contribute.
*/ | NatSpecMultiLine | _preValidatePurchase | function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
onlyIfWhitelisted(_beneficiary)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
| /**
* @dev Extend parent behavior requiring beneficiary to be in whitelist.
* @param _beneficiary Token beneficiary
* @param _weiAmount Amount of wei contributed
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://6b8905e6549fc07023c54ef0650d725104c0023b50f838faf77d38155f821f29 | {
"func_code_index": [
241,
450
]
} | 2,986 | |
EctoCrowdsale | contracts/BonusCrowdsale.sol | 0x80283ce9f88585ed571d72aa105b8aa56da96821 | Solidity | BonusCrowdsale | contract BonusCrowdsale is WhitelistedPausableCrowdsale
{
uint256[] public bonuses;
uint256[] public thresholds;
constructor(uint256[] _thresholds, uint256[] _bonuses) public
{
setBonusThresholds(_thresholds, _bonuses);
}
function setBonusThresholds(uint256[] _thresholds, uin... | /**
* @dev Allows better rates for tokens, based on Ether amounts.
* Thresholds must be in decending order.
*/ | NatSpecMultiLine | _getTokenAmount | function _getTokenAmount(uint256 _weiAmount)
internal view returns(uint256)
{
for (uint i = 0; i < thresholds.length; i++)
{
if (_weiAmount >= thresholds[i])
{
return _weiAmount.mul(rate.mul(100 + bonuses[i]).div(100));
}
}
return _weiAmount.mul(rate);
}
... | /**
* @dev Overrides parent method taking into account variable rate.
* @param _weiAmount The value in wei to be converted into tokens
* @return The number of tokens _weiAmount wei will buy at present time
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://6b8905e6549fc07023c54ef0650d725104c0023b50f838faf77d38155f821f29 | {
"func_code_index": [
839,
1207
]
} | 2,987 | |
Curve_ZapIn_General_V5 | contracts/Curve/Curve_ZapIn_General_V4.sol | 0x5ce9b49b7a1be9f2c3dc2b2a5bacea56fa21fbee | Solidity | Curve_ZapIn_General_V5 | contract Curve_ZapIn_General_V5 is ZapInBaseV3_1 {
using SafeERC20 for IERC20;
ICurveRegistry public curveReg;
address private constant wethTokenAddress =
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
constructor(
ICurveRegistry _curveRegistry,
uint256 _goodwill,
uint256... | ZapIn | function ZapIn(
address fromTokenAddress,
address toTokenAddress,
address swapAddress,
uint256 incomingTokenQty,
uint256 minPoolTokens,
address swapTarget,
bytes calldata swapData,
address affiliate
) external payable stopInEmergency returns (uint256 crvTokensBought) {
uint256 toInve... | /**
@notice This function adds liquidity to a Curve pool with ETH or ERC20 tokens
@param fromTokenAddress The token used for entry (address(0) if ether)
@param toTokenAddress The intermediate ERC20 token to swap to
@param swapAddress Curve swap address for the pool
@param incomingTokenQty The amount of fromTokenAd... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | GNU GPLv2 | {
"func_code_index": [
1350,
2477
]
} | 2,988 | |||
Curve_ZapIn_General_V5 | contracts/Curve/Curve_ZapIn_General_V4.sol | 0x5ce9b49b7a1be9f2c3dc2b2a5bacea56fa21fbee | Solidity | Curve_ZapIn_General_V5 | contract Curve_ZapIn_General_V5 is ZapInBaseV3_1 {
using SafeERC20 for IERC20;
ICurveRegistry public curveReg;
address private constant wethTokenAddress =
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
constructor(
ICurveRegistry _curveRegistry,
uint256 _goodwill,
uint256... | _enterMetaPool | function _enterMetaPool(
address swapAddress,
address toTokenAddress,
uint256 swapTokens
) internal returns (uint256 tokensBought, uint256 index) {
address[4] memory poolTokens = curveReg.getPoolTokens(swapAddress);
for (uint256 i = 0; i < 4; i++) {
address intermediateSwapAddress =
... | /**
@notice This function gets adds the liquidity for meta pools and returns the token index and swap tokens
@param swapAddress Curve swap address for the pool
@param toTokenAddress The ERC20 token to which from token to be convert
@param swapTokens quantity of toToken to invest
@return tokensBought quantity of cu... | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | GNU GPLv2 | {
"func_code_index": [
4542,
5393
]
} | 2,989 | |||
Curve_ZapIn_General_V5 | contracts/Curve/Curve_ZapIn_General_V4.sol | 0x5ce9b49b7a1be9f2c3dc2b2a5bacea56fa21fbee | Solidity | Curve_ZapIn_General_V5 | contract Curve_ZapIn_General_V5 is ZapInBaseV3_1 {
using SafeERC20 for IERC20;
ICurveRegistry public curveReg;
address private constant wethTokenAddress =
0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
constructor(
ICurveRegistry _curveRegistry,
uint256 _goodwill,
uint256... | _enterCurve | function _enterCurve(
address swapAddress,
uint256 amount,
uint256 index
) internal returns (uint256 crvTokensBought) {
address tokenAddress = curveReg.getTokenAddress(swapAddress);
address depositAddress = curveReg.getDepositAddress(swapAddress);
uint256 initialBalance = _getBalance(tokenAddres... | /**
@notice This function adds liquidity to a curve pool
@param swapAddress Curve swap address for the pool
@param amount The quantity of tokens being added as liquidity
@param index The token index for the add_liquidity call
@return crvTokensBought the quantity of curve LP tokens received
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | GNU GPLv2 | {
"func_code_index": [
6805,
9043
]
} | 2,990 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721Receiver | contract ERC721Receiver {
/**
* @dev Magic value to be returned upon successful reception of an NFT
* Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`,
* which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
*/
bytes4 internal constant ERC721... | // produced by the Solididy File Flattener (c) David Appleton 2018
// contact : dave@akomba.com
// released under Apache 2.0 licence
// input /home/phillip/Projects/cryptocare/contracts/contracts/CryptoCareMinter.sol
// flattened : Saturday, 20-Oct-18 22:15:01 UTC | LineComment | onERC721Received | function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes _data
)
public
returns(bytes4);
| /**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a `safetransfer`. This function MAY throw to revert and reject the
* transfer. Return of other than the magic value MUST result in the
* transaction being reverted.
* Note: the contract ... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1079,
1231
]
} | 2,991 | |
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | AddressUtils | library AddressUtils {
/**
* Returns whether the target address is a contract
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param addr address to check
* @return whether the ... | isContract | function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how... | /**
* Returns whether the target address is a contract
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param addr address to check
* @return whether the target address is a contract
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
357,
947
]
} | 2,992 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a... | /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
89,
476
]
} | 2,993 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
560,
840
]
} | 2,994 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
954,
1070
]
} | 2,995 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://githu... | add | function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1134,
1264
]
} | 2,996 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* a... | renounceOwnership | function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
815,
932
]
} | 2,997 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* a... | transferOwnership | function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1097,
1205
]
} | 2,998 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* a... | _transferOwnership | function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
| /**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
1343,
1521
]
} | 2,999 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC165 | interface ERC165 {
/**
* @notice Query if a contract implements an interface
* @param _interfaceId The interface identifier, as specified in ERC-165
* @dev Interface identification is specified in ERC-165. This function
* uses less than 30,000 gas.
*/
function supportsInterface(bytes4 _inter... | supportsInterface | function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
| /**
* @notice Query if a contract implements an interface
* @param _interfaceId The interface identifier, as specified in ERC-165
* @dev Interface identification is specified in ERC-165. This function
* uses less than 30,000 gas.
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
278,
373
]
} | 3,000 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function ... | pause | function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
| /**
* @dev called by the owner to pause, triggers stopped state
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
513,
609
]
} | 3,001 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function ... | unpause | function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
| /**
* @dev called by the owner to unpause, returns to normal state
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
693,
791
]
} | 3,002 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | SupportsInterfaceWithLookup | contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*/
/**
* @dev a mapping of interface id to whether or not it's supported
*/
mapping(bytes4 => bool) internal ... | supportsInterface | function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
| /**
* @dev implement supportsInterface(bytes4) using a lookup table
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
619,
770
]
} | 3,003 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | SupportsInterfaceWithLookup | contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*/
/**
* @dev a mapping of interface id to whether or not it's supported
*/
mapping(bytes4 => bool) internal ... | _registerInterface | function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
| /**
* @dev private method for registering an interface
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
842,
1006
]
} | 3,004 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | balanceOf | function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
| /**
* @dev Gets the balance of the specified address
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
2558,
2706
]
} | 3,005 | |||
CryptoCareMinter | CryptoCareMinter.sol | 0xde870fd5dcabc964c0c56dbf80ccb1cced5ad208 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
*... | ownerOf | function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
| /**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://a6b808c2bc7fc9d5a0629b101e21987af4081aa292244c9af56310ea4c318c63 | {
"func_code_index": [
2923,
3094
]
} | 3,006 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.