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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | balanceOf | function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
| // ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
2392,
2517
]
} | 6,607 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | transfer | function transfer(address to, uint tokens) onlyPayloadSize(2 * 32) public returns (bool success) {
require(to != address(0));
require(tokens <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to... | // ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
2861,
3247
]
} | 6,608 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | approve | function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval do... | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
3758,
3971
]
} | 6,609 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | transferFrom | function transferFrom(address from, address to, uint tokens) onlyPayloadSize(3 * 32) public returns (bool success) {
require(tokens <= balances[from]);
require(tokens <= allowed[from][msg.sender]);
require(to != address(0));
balances[from] = balances[from].sub(tokens);
balances[to] = balanc... | // ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer... | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
4509,
5022
]
} | 6,610 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | allowance | function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
| // ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
5305,
5457
]
} | 6,611 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | approveAndCall | function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
| // ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------... | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
5820,
6142
]
} | 6,612 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | transferAnyERC20Token | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
| // ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
6373,
6562
]
} | 6,613 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | getBalance | function getBalance(address _address) internal returns (uint256) {
if (_airdropTotal < _airdropSupply && !initialized[_address]) {
return balances[_address] + _airdropAmount;
} else {
return balances[_address];
}
}
| // ------------------------------------------------------------------------
// Get the airdrop token balance for account `tokenOwner`
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
6790,
7067
]
} | 6,614 | |
BBT | BBT.sol | 0x4b2cc07661c7b69a4707277647727aa8898ffbde | Solidity | BBT | contract BBT is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyWhitelist() {
... | // ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and a
// fixed supply
// ---------------------------------------------------------------------------- | LineComment | distr | function distr(address _to, uint256 _amount) canDistr private returns (bool) {
_airdropTotal = _airdropTotal.add(_amount);
_totalRemaining = _totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
if (_a... | // ------------------------------------------------------------------------
// internal private functions
// ------------------------------------------------------------------------ | LineComment | v0.4.24+commit.e67f0147 | bzzr://f60236597425deaccb71e97847747c533f20c62a038dc91faefc0b2722993aca | {
"func_code_index": [
7267,
7708
]
} | 6,615 | |
MetaverseIdV1 | Reservation.sol | 0x84f94e7b73e9f901b0470d9d7cb389ca0017b81f | Solidity | MetaverseIdV1 | contract MetaverseIdV1 is ERC721, Ownable, ReentrancyGuard {
// initial configuration
uint256 nextId = 1;
// Where to look for ERC-721 token metadata
string metadataServer;
// Maps usernames to NFT token IDs and back
mapping (string => uint256) public handleToId;
mapping (uint256 => string... | mint | function mint(string memory handle, address owner) external onlyController nonReentrant {
require(handleToId[handle] == 0, "already-exists");
uint256 id = nextId;
nextId++;
handleToId[handle] = id;
idToHandle[id] = handle;
emit Mint(owner, id, handle);
_safeMint(owner, id);
}
| // Controller Functions | LineComment | v0.8.10+commit.fc410830 | MIT | {
"func_code_index": [
901,
1241
]
} | 6,616 | |||
MetaverseIdV1 | Reservation.sol | 0x84f94e7b73e9f901b0470d9d7cb389ca0017b81f | Solidity | MetaverseIdV1 | contract MetaverseIdV1 is ERC721, Ownable, ReentrancyGuard {
// initial configuration
uint256 nextId = 1;
// Where to look for ERC-721 token metadata
string metadataServer;
// Maps usernames to NFT token IDs and back
mapping (string => uint256) public handleToId;
mapping (uint256 => string... | addController | function addController(address controller) external onlyOwner {
controllers[controller] = true;
emit ControllerAdded(controller);
}
| // Admin Functions
// Authorises a controller, who can mint new IDs | LineComment | v0.8.10+commit.fc410830 | MIT | {
"func_code_index": [
1320,
1475
]
} | 6,617 | |||
MetaverseIdV1 | Reservation.sol | 0x84f94e7b73e9f901b0470d9d7cb389ca0017b81f | Solidity | MetaverseIdV1 | contract MetaverseIdV1 is ERC721, Ownable, ReentrancyGuard {
// initial configuration
uint256 nextId = 1;
// Where to look for ERC-721 token metadata
string metadataServer;
// Maps usernames to NFT token IDs and back
mapping (string => uint256) public handleToId;
mapping (uint256 => string... | removeController | function removeController(address controller) external onlyOwner {
controllers[controller] = false;
emit ControllerRemoved(controller);
}
| // Revoke controller permission for an address. | LineComment | v0.8.10+commit.fc410830 | MIT | {
"func_code_index": [
1529,
1690
]
} | 6,618 | |||
MetaverseIdV1 | Reservation.sol | 0x84f94e7b73e9f901b0470d9d7cb389ca0017b81f | Solidity | MetaverseIdV1 | contract MetaverseIdV1 is ERC721, Ownable, ReentrancyGuard {
// initial configuration
uint256 nextId = 1;
// Where to look for ERC-721 token metadata
string metadataServer;
// Maps usernames to NFT token IDs and back
mapping (string => uint256) public handleToId;
mapping (uint256 => string... | setMetadataServer | function setMetadataServer(string memory newServer) external onlyOwner {
metadataServer = newServer;
emit MetadataServerChanged(newServer);
}
| // changes the metadata server | LineComment | v0.8.10+commit.fc410830 | MIT | {
"func_code_index": [
1727,
1892
]
} | 6,619 | |||
MetaverseIdV1 | Reservation.sol | 0x84f94e7b73e9f901b0470d9d7cb389ca0017b81f | Solidity | MetaverseIdV1 | contract MetaverseIdV1 is ERC721, Ownable, ReentrancyGuard {
// initial configuration
uint256 nextId = 1;
// Where to look for ERC-721 token metadata
string metadataServer;
// Maps usernames to NFT token IDs and back
mapping (string => uint256) public handleToId;
mapping (uint256 => string... | tokenURI | function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
return string(abi.encodePacked(metadataServer, idToHandle[tokenId], ".json"));
}
| // NFT Standard | LineComment | v0.8.10+commit.fc410830 | MIT | {
"func_code_index": [
2038,
2310
]
} | 6,620 | |||
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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... | /**
* @title ERC165
* @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
*/ | NatSpecMultiLine | 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.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
278,
373
]
} | 6,621 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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) interna... | /**
* @title SupportsInterfaceWithLookup
* @author Matt Condon (@shrugs)
* @dev Implements ERC165 using a lookup table.
*/ | NatSpecMultiLine | supportsInterface | function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
| /**
* @dev implement supportsInterface(bytes4) using a lookup table
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
621,
772
]
} | 6,622 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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) interna... | /**
* @title SupportsInterfaceWithLookup
* @author Matt Condon (@shrugs)
* @dev Implements ERC165 using a lookup table.
*/ | NatSpecMultiLine | _registerInterface | function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
| /**
* @dev private method for registering an interface
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
844,
1008
]
} | 6,623 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://gith... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mul | function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint... | /**
* @dev Multiplies two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
90,
493
]
} | 6,624 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://gith... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | div | function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
605,
893
]
} | 6,625 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://gith... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | sub | function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
| /**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1008,
1153
]
} | 6,626 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://gith... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | add | function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
| /**
* @dev Adds two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1218,
1362
]
} | 6,627 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://gith... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| /**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1497,
1614
]
} | 6,628 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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 _account address of the account to check
* @... | /**
* Utility library of inline functions on addresses
*/ | NatSpecMultiLine | isContract | function isContract(address _account) 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... | /**
* 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 _account address of the account to check
* @return whether the target address is a... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
376,
974
]
} | 6,629 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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... | /**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/ | NatSpecMultiLine | 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 a... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1079,
1231
]
} | 6,630 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | 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.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1161,
1309
]
} | 6,631 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | 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.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1526,
1697
]
} | 6,632 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | approve | function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
| /**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given t... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
2109,
2396
]
} | 6,633 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | getApproved | function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
| /**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
2627,
2743
]
} | 6,634 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | setApprovalForAll | function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
| /**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
3028,
3240
]
} | 6,635 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | isApprovedForAll | function isApprovedForAll(
address _owner,
address _operator
)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
| /**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
3554,
3734
]
} | 6,636 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | transferFrom | function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
require(isApprovedOrOwner(msg.sender, _tokenId));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId... | /**
* @dev Transfers the ownership of a given token ID to another address
* Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of ... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
4159,
4513
]
} | 6,637 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
| /**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
5140,
5351
]
} | 6,638 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | safeTransferFrom | function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
| /**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
6044,
6334
]
} | 6,639 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | _exists | function _exists(uint256 _tokenId) internal view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
| /**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existence of
* @return whether the token exists
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
6516,
6665
]
} | 6,640 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | isApprovedOrOwner | function isApprovedOrOwner(
address _spender,
uint256 _tokenId
)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (
_spender ... | /**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of ... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
7018,
7476
]
} | 6,641 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | _mint | function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
| /**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
7730,
7906
]
} | 6,642 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | _burn | function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
| /**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
8096,
8291
]
} | 6,643 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | clearApproval | function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
}
}
| /**
* @dev Internal function to clear current approval of a given token ID
* Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
8558,
8780
]
} | 6,644 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | addTokenTo | function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
| /**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
9047,
9258
]
} | 6,645 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | removeTokenFrom | function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
| /**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
9541,
9762
]
} | 6,646 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721BasicToken | contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | checkAndCallSafeTransfer | function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(
msg.sender, _from, _tokenId, _data);
return (retval == ERC721_R... | /**
* @dev Internal function to invoke `onERC721Received` on a target address
* The call is not executed if the target address is not a contract
* @param _from address representing the previous owner of the given token ID
* @param _to target address that will receive the tokens
* @param _tokenId uint256 ID of... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
10276,
10641
]
} | 6,647 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | name | function name() external view returns (string) {
return name_;
}
| /**
* @dev Gets the token name
* @return string representing the token name
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1136,
1211
]
} | 6,648 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | symbol | function symbol() external view returns (string) {
return symbol_;
}
| /**
* @dev Gets the token symbol
* @return string representing the token symbol
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1312,
1391
]
} | 6,649 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | tokenURI | function tokenURI(uint256 _tokenId) public view returns (string) {
require(_exists(_tokenId));
return tokenURIs[_tokenId];
}
| /**
* @dev Returns an URI for a given token ID
* Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1583,
1723
]
} | 6,650 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
| /**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned ... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
2089,
2305
]
} | 6,651 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return allTokens.length;
}
| /**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
2450,
2542
]
} | 6,652 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
| /**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
2871,
3017
]
} | 6,653 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | _setTokenURI | function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(_exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
| /**
* @dev Internal function to set the token URI for a given token
* Reverts if the token ID does not exist
* @param _tokenId uint256 ID of the token to set its URI
* @param _uri string URI to assign
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
3247,
3384
]
} | 6,654 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | addTokenTo | function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
| /**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
3651,
3885
]
} | 6,655 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | removeTokenFrom | function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastToke... | /**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
4168,
5212
]
} | 6,656 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | _mint | function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
| /**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to address the beneficiary that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
5478,
5658
]
} | 6,657 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | ERC721Token | contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to inde... | /**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | _burn | function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex ... | /**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _owner owner of the token to burn
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
5895,
6502
]
} | 6,658 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
| /**
* @dev Allows the current owner to relinquish control of the contract.
* @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.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
815,
932
]
} | 6,659 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address _newOwner) public onlyOwner {
_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.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1097,
1205
]
} | 6,660 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | 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... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | _transferOwnership | function _transferOwnership(address _newOwner) 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.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1343,
1521
]
} | 6,661 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | toSlice | function toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
| /*
* @dev Returns a slice containing the entire string.
* @param self The string to make a slice from.
* @return A newly allocated slice containing the entire string.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
860,
1081
]
} | 6,662 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | len | function len(bytes32 self) internal pure returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
... | /*
* @dev Returns the length of a null-terminated bytes32 string.
* @param self The value to find the length of.
* @return The length of the string, from 0 to 32.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
1279,
2076
]
} | 6,663 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | toSliceB32 | function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
r... | /*
* @dev Returns a slice containing the entire bytes32, interpreted as a
* null-terminated utf-8 string.
* @param self The bytes32 value to convert to a slice.
* @return A new slice containing the value of the input argument up to the
* first null.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
2386,
2770
]
} | 6,664 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | copy | function copy(slice memory self) internal pure returns (slice memory) {
return slice(self._len, self._ptr);
}
| /*
* @dev Returns a new slice containing the same data as the current slice.
* @param self The slice to copy.
* @return A new slice containing the same data as `self`.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
2973,
3101
]
} | 6,665 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | toString | function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
| /*
* @dev Copies a slice to a new string.
* @param self The slice to copy.
* @return A newly allocated string containing the slice's text.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
3275,
3552
]
} | 6,666 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | len | function len(slice memory self) internal pure returns (uint l) {
// Starting at ptr-31 means the LSB will be the byte we care about
uint ptr = self._ptr - 31;
uint end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b <... | /*
* @dev Returns the length in runes of the slice. Note that this operation
* takes time proportional to the length of the slice; avoid using it
* in loops, and call `slice.empty()` if you only need to know whether
* the slice is empty or not.
* @param self The slice to operate on.
* @return... | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
3948,
4666
]
} | 6,667 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | empty | function empty(slice memory self) internal pure returns (bool) {
return self._len == 0;
}
| /*
* @dev Returns true if the slice is empty (has a length of 0).
* @param self The slice to operate on.
* @return True if the slice is empty, False otherwise.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
4861,
4969
]
} | 6,668 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | compare | function compare(slice memory self, slice memory other) internal pure returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
uint selfptr = self._ptr;
uint otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
... | /*
* @dev Returns a positive number if `other` comes lexicographically after
* `self`, a negative number if it comes before, or zero if the
* contents of the two slices are equal. Comparison is done per-rune,
* on unicode codepoints.
* @param self The first slice to compare.
* @param other Th... | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
5403,
6427
]
} | 6,669 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | equals | function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
| /*
* @dev Returns true if the two slices contain the same text.
* @param self The first slice to compare.
* @param self The second slice to compare.
* @return True if the slices are equal, false otherwise.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
6674,
6814
]
} | 6,670 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | nextRune | function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint l;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mlo... | /*
* @dev Extracts the first rune in the slice into `rune`, advancing the
* slice to point to the next rune and returning `self`.
* @param self The slice to operate on.
* @param rune The slice that will contain the first rune.
* @return `rune`.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
7111,
8028
]
} | 6,671 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | nextRune | function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
| /*
* @dev Returns the first rune in the slice, advancing the slice to point
* to the next rune.
* @param self The slice to operate on.
* @return A slice containing only the first rune from `self`.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
8271,
8392
]
} | 6,672 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | ord | function ord(slice memory self) internal pure returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if ... | /*
* @dev Returns the number of the first codepoint in the slice.
* @param self The slice to operate on.
* @return The number of the first codepoint in the slice.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
8590,
9715
]
} | 6,673 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | keccak | function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
| /*
* @dev Returns the keccak-256 hash of the slice.
* @param self The slice to hash.
* @return The hash of the slice.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
9868,
10048
]
} | 6,674 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | startsWith | function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr :=... | /*
* @dev Returns true if `self` starts with `needle`.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return True if the slice starts with the provided text, false otherwise.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
10300,
10867
]
} | 6,675 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | beyond | function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(ad... | /*
* @dev If `self` starts with `needle`, `needle` is removed from the
* beginning of `self`. Otherwise, `self` is unmodified.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return `self`
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
11143,
11830
]
} | 6,676 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | endsWith | function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
uint selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
... | /*
* @dev Returns true if the slice ends with `needle`.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return True if the slice starts with the provided text, false otherwise.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
12083,
12660
]
} | 6,677 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | until | function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
uint selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let length... | /*
* @dev If `self` ends with `needle`, `needle` is removed from the
* end of `self`. Otherwise, `self` is unmodified.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return `self`
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
12928,
13579
]
} | 6,678 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | findPtr | function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr = selfptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata... | // Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found. | LineComment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
13735,
15149
]
} | 6,679 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | rfindPtr | function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly ... | // Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found. | LineComment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
15301,
16718
]
} | 6,680 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | find | function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
| /*
* @dev Modifies `self` to contain everything from the first occurrence of
* `needle` to the end of the slice. `self` is set to the empty slice
* if `needle` is not found.
* @param self The slice to search and modify.
* @param needle The text to search for.
* @return `self`.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
17059,
17327
]
} | 6,681 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | rfind | function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
| /*
* @dev Modifies `self` to contain the part of the string from the start of
* `self` to the end of the first occurrence of `needle`. If `needle`
* is not found, `self` is set to the empty slice.
* @param self The slice to search and modify.
* @param needle The text to search for.
* @return `self... | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
17691,
17934
]
} | 6,682 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | split | function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
... | /*
* @dev Splits the slice, setting `self` to everything after the first
* occurrence of `needle`, and `token` to everything before it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and `token` is set to the entirety of `self`.
* @param self The slice to split.
*... | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
18447,
18968
]
} | 6,683 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | split | function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
split(self, needle, token);
}
| /*
* @dev Splits the slice, setting `self` to everything after the first
* occurrence of `needle`, and returning everything before it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and the entirety of `self` is returned.
* @param self The slice to split.
* @param... | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
19445,
19593
]
} | 6,684 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | rsplit | function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
... | /*
* @dev Splits the slice, setting `self` to everything before the last
* occurrence of `needle`, and `token` to everything after it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and `token` is set to the entirety of `self`.
* @param self The slice to split.
* ... | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
20105,
20580
]
} | 6,685 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | rsplit | function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
| /*
* @dev Splits the slice, setting `self` to everything before the last
* occurrence of `needle`, and returning everything after it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and the entirety of `self` is returned.
* @param self The slice to split.
* @param ... | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
21055,
21205
]
} | 6,686 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | count | function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
cnt++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr... | /*
* @dev Counts the number of nonoverlapping occurrences of `needle` in `self`.
* @param self The slice to search.
* @param needle The text to search for in `self`.
* @return The number of occurrences of `needle` found in `self`.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
21477,
21852
]
} | 6,687 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | contains | function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
| /*
* @dev Returns True if `self` contains `needle`.
* @param self The slice to search.
* @param needle The text to search for in `self`.
* @return True if `needle` is found in `self`, false otherwise.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
22094,
22281
]
} | 6,688 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | concat | function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
... | /*
* @dev Returns a newly allocated string containing the concatenation of
* `self` and `other`.
* @param self The first slice to concatenate.
* @param other The second slice to concatenate.
* @return The concatenation of the two strings.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
22572,
22939
]
} | 6,689 | |
CarToken | CarToken.sol | 0x5caebd3b32e210e85ce3e9d51638b9c445481567 | Solidity | strings | library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
... | /*
* @title String & slice utility library for Solidity contracts.
* @author Nick Johnson <arachnid@notdot.net>
*
* @dev Functionality in this library is largely implemented using an
* abstraction called a 'slice'. A slice represents a part of a string -
* anything from the entire string to a sing... | Comment | join | function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
if (parts.length == 0)
return "";
uint length = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
length += parts[i]._len;
string memory ret = new string(length);... | /*
* @dev Joins an array of slices, using `self` as a delimiter, returning a
* newly allocated string.
* @param self The delimiter to use.
* @param parts A list of slices to join.
* @return A newly allocated string containing all the slices in `parts`,
* joined with `self`.
*/ | Comment | v0.4.24+commit.e67f0147 | bzzr://473b9a412b765137470a2795f1072f6b585fb45d4e9ad8b54ba1897071f67688 | {
"func_code_index": [
23280,
24030
]
} | 6,690 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256... | /**
* @dev Multiplies two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
90,
486
]
} | 6,691 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
598,
877
]
} | 6,692 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| /**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
992,
1131
]
} | 6,693 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| /**
* @dev Adds two numbers, reverts on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
1196,
1335
]
} | 6,694 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github... | /**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/ | NatSpecMultiLine | mod | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| /**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
1470,
1587
]
} | 6,695 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | totalSupply | function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| /**
* @dev Total number of tokens in existence
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
281,
369
]
} | 6,696 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
| /**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
570,
673
]
} | 6,697 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | allowance | function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
| /**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
995,
1150
]
} | 6,698 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transfer | function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
| /**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
1306,
1439
]
} | 6,699 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | approve | function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_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
* race... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
2063,
2292
]
} | 6,700 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | transferFrom | function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
| /**
* @dev Transfer tokens from one address to another
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
2569,
2869
]
} | 6,701 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | increaseAllowance | function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| /**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender T... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
3328,
3668
]
} | 6,702 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | decreaseAllowance | function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;... | /**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender T... | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
4132,
4482
]
} | 6,703 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | _transfer | function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| /**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
4687,
4974
]
} | 6,704 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | _mint | function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| /**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
5307,
5550
]
} | 6,705 | |
ALLMEDICOIN | ALLMEDICOIN.sol | 0xfb61d5a3ac90ee74ce345173394b9ad88347c7f3 | Solidity | ERC20 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view re... | /**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/ | NatSpecMultiLine | _burn | function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
| /**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://add8aff710a4f9fc0014d73653ec2cdede69a11680ffc20dc3883684e386b0f5 | {
"func_code_index": [
5767,
6055
]
} | 6,706 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.