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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC165 | contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*/
/**
* @dev a mapping of interface id to whether or not it's supported
*/
mapping(bytes4 => bool) internal _supportedInterf... | /**
* @title ERC165
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
605,
755
]
} | 5,207 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC165 | contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*/
/**
* @dev a mapping of interface id to whether or not it's supported
*/
mapping(bytes4 => bool) internal _supportedInterf... | /**
* @title ERC165
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
827,
989
]
} | 5,208 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | IERC721Receiver | contract IERC721Receiver {
/**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a `safeTransfer`. This function MUST return the function selector,
* otherwise the caller will revert the transaction. The selector to be
* returned ... | /**
* @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 MUST return the function selector,
* otherwise the caller will revert the transaction. The selector to be
* returned can be obtained as `this.onERC721Receive... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
865,
1013
]
} | 5,209 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
90,
486
]
} | 5,210 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
598,
877
]
} | 5,211 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
992,
1131
]
} | 5,212 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1196,
1335
]
} | 5,213 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1470,
1587
]
} | 5,214 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | Address | library Address {
/**
* 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... | /**
* 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
370,
966
]
} | 5,215 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1773,
1919
]
} | 5,216 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
2135,
2305
]
} | 5,217 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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 to... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
2715,
2995
]
} | 5,218 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
| /**
* @dev Gets the approved address for a token ID, or zero if no address set
* Reverts if the token ID does not exist.
* @param tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
3271,
3418
]
} | 5,219 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
3701,
3907
]
} | 5,220 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
4219,
4396
]
} | 5,221 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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 th... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
4818,
5162
]
} | 5,222 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
5786,
5991
]
} | 5,223 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
6681,
6963
]
} | 5,224 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
7144,
7292
]
} | 5,225 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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 th... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
7643,
8095
]
} | 5,226 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
8347,
8517
]
} | 5,227 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
8706,
8895
]
} | 5,228 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
9160,
9379
]
} | 5,229 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
9644,
9853
]
} | 5,230 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
10134,
10352
]
} | 5,231 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721 | contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x... | /**
* @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 = IERC721Receiver(to).onERC721Received(
msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEI... | /**
* @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 th... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
10863,
11224
]
} | 5,232 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Enumerable | contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all tok... | 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 by... | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1347,
1558
]
} | 5,233 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Enumerable | contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all tok... | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1703,
1796
]
} | 5,234 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Enumerable | contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all tok... | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
2124,
2268
]
} | 5,235 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Enumerable | contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all tok... | _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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
2533,
2764
]
} | 5,236 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Enumerable | contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all tok... | _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 lastTokenI... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
3045,
4087
]
} | 5,237 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Enumerable | contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all tok... | _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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
4351,
4528
]
} | 5,238 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Enumerable | contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all tok... | _burn | function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Reorg all tokens array
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 lastToken = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastToken;
... | /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
4763,
5245
]
} | 5,239 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Metadata | contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
/**
... | name | function name() external view returns (string) {
return _name;
}
| /**
* @dev Gets the token name
* @return string representing the token name
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
846,
921
]
} | 5,240 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Metadata | contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
/**
... | symbol | function symbol() external view returns (string) {
return _symbol;
}
| /**
* @dev Gets the token symbol
* @return string representing the token symbol
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1022,
1101
]
} | 5,241 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Metadata | contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
/**
... | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1292,
1430
]
} | 5,242 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Metadata | contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
/**
... | _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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1658,
1791
]
} | 5,243 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | ERC721Metadata | contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
/**
... | _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];
}
}
| /**
* @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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
2026,
2252
]
} | 5,244 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
860,
1081
]
} | 5,245 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
1279,
2076
]
} | 5,246 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
2386,
2770
]
} | 5,247 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
2973,
3101
]
} | 5,248 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
3275,
3552
]
} | 5,249 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
3948,
4666
]
} | 5,250 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
4861,
4969
]
} | 5,251 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
5403,
6427
]
} | 5,252 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
6674,
6814
]
} | 5,253 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
7111,
8028
]
} | 5,254 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
8271,
8392
]
} | 5,255 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
8590,
9715
]
} | 5,256 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
9868,
10048
]
} | 5,257 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
10300,
10867
]
} | 5,258 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
11143,
11830
]
} | 5,259 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
12083,
12660
]
} | 5,260 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
12928,
13579
]
} | 5,261 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
13735,
15149
]
} | 5,262 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
15301,
16718
]
} | 5,263 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
17059,
17327
]
} | 5,264 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
17691,
17934
]
} | 5,265 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
18447,
18968
]
} | 5,266 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
19445,
19593
]
} | 5,267 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
20105,
20580
]
} | 5,268 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
21055,
21205
]
} | 5,269 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
21477,
21852
]
} | 5,270 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
22094,
22281
]
} | 5,271 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
22572,
22939
]
} | 5,272 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | 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.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
23280,
24030
]
} | 5,273 | |
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | CarFactory | contract CarFactory is Ownable {
using strings for *;
uint256 public constant MAX_CARS = 30000 + 150000 + 1000000;
uint256 public mintedCars = 0;
address preOrderAddress;
CarToken token;
mapping(uint256 => uint256) public tankSizes;
mapping(uint256 => uint) public savedTypes;
... | attachPreOrder | function attachPreOrder(address dst) public onlyOwner {
require(preOrderAddress == address(0));
require(dst != address(0));
//Enforce that address is indeed a preorder
PreOrder preOrder = PreOrder(dst);
preOrderAddress = address(preOrder);
}
| /**
Attach the preOrder that will be receiving tokens being marked for sale by the
sellCar function
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
4095,
4395
]
} | 5,274 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | CarFactory | contract CarFactory is Ownable {
using strings for *;
uint256 public constant MAX_CARS = 30000 + 150000 + 1000000;
uint256 public mintedCars = 0;
address preOrderAddress;
CarToken token;
mapping(uint256 => uint256) public tankSizes;
mapping(uint256 => uint) public savedTypes;
... | attachToken | function attachToken(address dst) public onlyOwner {
require(address(token) == address(0));
require(dst != address(0));
//Enforce that address is indeed a preorder
CarToken ct = CarToken(dst);
token = ct;
}
| /**
Attach the token being used for things
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
4459,
4724
]
} | 5,275 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | PreOrder | contract PreOrder is Destructible {
/**
* The current price for any given type (int)
*/
mapping(uint => uint256) public currentTypePrice;
// Maps Premium car variants to the tokens minted for their description
// INPUT: variant #
// OUTPUT: list of cars
mapping(uint => uint25... | setTypePrice | function setTypePrice(uint cType, uint256 price) public onlyOwner {
if (currentTypePrice[cType] == 0) {
require(price > 0, "Price already set");
currentTypePrice[cType] = price;
}
}
| /**
* Set the starting price for any given type. Can only be set once, and value must be greater than 0
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
5346,
5581
]
} | 5,276 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | PreOrder | contract PreOrder is Destructible {
/**
* The current price for any given type (int)
*/
mapping(uint => uint256) public currentTypePrice;
// Maps Premium car variants to the tokens minted for their description
// INPUT: variant #
// OUTPUT: list of cars
mapping(uint => uint25... | withdraw | function withdraw(uint256 amount) public onlyOwner {
uint256 balance = address(this).balance;
require(amount <= balance, "Requested to much");
owner().transfer(amount);
emit Withdrawal(amount);
}
| /**
Withdraw the amount from the contract's balance. Only the contract owner can execute this function
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
5705,
5950
]
} | 5,277 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | PreOrder | contract PreOrder is Destructible {
/**
* The current price for any given type (int)
*/
mapping(uint => uint256) public currentTypePrice;
// Maps Premium car variants to the tokens minted for their description
// INPUT: variant #
// OUTPUT: list of cars
mapping(uint => uint25... | priceFor | function priceFor(uint cType) public view returns (uint256) {
uint256 percent = percentIncrease[cType];
uint256 base = percentBase[cType];
uint256 currentPrice = currentTypePrice[cType];
uint256 nextPrice = (currentPrice * percent);
//Return the next price, as this is the true price
re... | /**
Get the price for any car with the given _tokenId
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
11105,
11483
]
} | 5,278 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | BatchPreOrder | contract BatchPreOrder is Destructible {
/**
* The current price for any given type (int)
*/
mapping(uint => uint256) public currentTypePrice;
// Maps Premium car variants to the tokens minted for their description
// INPUT: variant #
// OUTPUT: list of cars
mapping(uint => u... | setTypePrice | function setTypePrice(uint cType, uint256 price) public onlyOwner {
revert(); //NOT IMPLEMENTED
}
| /**
* Set the starting price for any given type. Can only be set once, and value must be greater than 0
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
5381,
5498
]
} | 5,279 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | BatchPreOrder | contract BatchPreOrder is Destructible {
/**
* The current price for any given type (int)
*/
mapping(uint => uint256) public currentTypePrice;
// Maps Premium car variants to the tokens minted for their description
// INPUT: variant #
// OUTPUT: list of cars
mapping(uint => u... | withdraw | function withdraw(uint256 amount) public onlyOwner {
uint256 balance = address(this).balance;
require(amount <= balance, "Requested to much");
owner().transfer(amount);
emit Withdrawal(amount);
}
| /**
Withdraw the amount from the contract's balance. Only the contract owner can execute this function
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
5622,
5867
]
} | 5,280 | |||
BatchPreOrder | BatchPreOrder.sol | 0xd558f0c903ccac458495f0dc776dbcc78f1adf79 | Solidity | BatchPreOrder | contract BatchPreOrder is Destructible {
/**
* The current price for any given type (int)
*/
mapping(uint => uint256) public currentTypePrice;
// Maps Premium car variants to the tokens minted for their description
// INPUT: variant #
// OUTPUT: list of cars
mapping(uint => u... | priceFor | function priceFor(uint cType) public view returns (uint256) {
revert(); //NOT IMPLEMENTED
}
| /**
Get the price for any car with the given _tokenId
*/ | NatSpecMultiLine | v0.4.25+commit.59dbf8f1 | bzzr://40803e85a639ed1f108b5ac71d85535c59732bc2f66ea68acc0216f6e033e4b7 | {
"func_code_index": [
8268,
8380
]
} | 5,281 | |||
Token | Token.sol | 0xbcf3c910482b3125063582374552d083cb36498c | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* Transfer token for a specified address
*
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
* @return bool
*/
function transfer(address _to, u... | /**
* Basic Token Contract
* Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| /**
* Transfer token for a specified address
*
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
* @return bool
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://59a49b343e076298ea7942b082ddd35cbfb9922f9cdb56ce94810ef89c0d039e | {
"func_code_index": [
286,
532
]
} | 5,282 | |
Token | Token.sol | 0xbcf3c910482b3125063582374552d083cb36498c | Solidity | BasicToken | contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* Transfer token for a specified address
*
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
* @return bool
*/
function transfer(address _to, u... | /**
* Basic Token Contract
* Basic version of StandardToken, with no allowances.
*/ | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
| /**
* Gets the balance of the specified address.
*
* @param _owner The address to query the the balance of.
* @return uint256
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://59a49b343e076298ea7942b082ddd35cbfb9922f9cdb56ce94810ef89c0d039e | {
"func_code_index": [
682,
798
]
} | 5,283 | |
Token | Token.sol | 0xbcf3c910482b3125063582374552d083cb36498c | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* 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
... | /**
* Standard ERC20 token
*
* Implementation of the basic standard token.
* Reference: https://github.com/ethereum/EIPs/issues/20
* 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) {
var _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// require (_value <= _allowance);
balances[_to] = balances[_to].a... | /**
* 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 amout of tokens to be transfered
* @return bool
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://59a49b343e076298ea7942b082ddd35cbfb9922f9cdb56ce94810ef89c0d039e | {
"func_code_index": [
408,
918
]
} | 5,284 | |
Token | Token.sol | 0xbcf3c910482b3125063582374552d083cb36498c | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* 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
... | /**
* Standard ERC20 token
*
* Implementation of the basic standard token.
* Reference: https://github.com/ethereum/EIPs/issues/20
* 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) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EI... | /**
* Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
* @return bool
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://59a49b343e076298ea7942b082ddd35cbfb9922f9cdb56ce94810ef89c0d039e | {
"func_code_index": [
1174,
1724
]
} | 5,285 | |
Token | Token.sol | 0xbcf3c910482b3125063582374552d083cb36498c | Solidity | StandardToken | contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* 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
... | /**
* Standard ERC20 token
*
* Implementation of the basic standard token.
* Reference: https://github.com/ethereum/EIPs/issues/20
* 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 constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| /**
* 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 uint256
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://59a49b343e076298ea7942b082ddd35cbfb9922f9cdb56ce94810ef89c0d039e | {
"func_code_index": [
1982,
2127
]
} | 5,286 | |
Token | Token.sol | 0xbcf3c910482b3125063582374552d083cb36498c | Solidity | Token | contract Token is StandardToken {
string public name;
string public symbol;
uint256 public initialSupply;
uint256 public decimals = 18;
/**
* Contructor that gives msg.sender all of existing tokens.
*/
function Token(uint256 _initialSupply, string _tokenName, string _tokenSymbol) public {
... | /**
* Token Contract
*
* Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
* Note they can later distribute these tokens as they wish using `transfer` and other
* `StandardToken` functions.
*/ | NatSpecMultiLine | Token | function Token(uint256 _initialSupply, string _tokenName, string _tokenSymbol) public {
totalSupply = _initialSupply * 10**18;
balances[msg.sender] = _initialSupply * 10**18;
initialSupply = _initialSupply * 10**18;
name = _tokenName;
symbol = _tokenSymbol;
}
| /**
* Contructor that gives msg.sender all of existing tokens.
*/ | NatSpecMultiLine | v0.4.19+commit.c4cbbb05 | bzzr://59a49b343e076298ea7942b082ddd35cbfb9922f9cdb56ce94810ef89c0d039e | {
"func_code_index": [
230,
522
]
} | 5,287 | |
WINR | openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol | 0x9ed2be37055f91ada030277ba6c06324996c1bc8 | Solidity | ERC20Burnable | abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Dest... | /**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burn | function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
| /**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://9e3eaacf5da8aca8c939f70d2fdcf27e611104dc67674366ac4ae390a442a76c | {
"func_code_index": [
196,
292
]
} | 5,288 |
WINR | openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol | 0x9ed2be37055f91ada030277ba6c06324996c1bc8 | Solidity | ERC20Burnable | abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
/**
* @dev Dest... | /**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/ | NatSpecMultiLine | burnFrom | function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
| /**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/ | NatSpecMultiLine | v0.6.12+commit.27d51765 | MIT | ipfs://9e3eaacf5da8aca8c939f70d2fdcf27e611104dc67674366ac4ae390a442a76c | {
"func_code_index": [
606,
906
]
} | 5,289 |
Airdrop | Airdrop.sol | 0x5be8142fe5bfce520750c67fb2bf3a15be313b1a | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | mul | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| /**
* @dev Multiplies two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://353555bc182defd75eb43996d232a0b02057c03a4cdfefbf58edfd7e6ea0f894 | {
"func_code_index": [
89,
272
]
} | 5,290 | |
Airdrop | Airdrop.sol | 0x5be8142fe5bfce520750c67fb2bf3a15be313b1a | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | div | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
| /**
* @dev Integer division of two numbers, truncating the quotient.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://353555bc182defd75eb43996d232a0b02057c03a4cdfefbf58edfd7e6ea0f894 | {
"func_code_index": [
356,
629
]
} | 5,291 | |
Airdrop | Airdrop.sol | 0x5be8142fe5bfce520750c67fb2bf3a15be313b1a | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| /**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://353555bc182defd75eb43996d232a0b02057c03a4cdfefbf58edfd7e6ea0f894 | {
"func_code_index": [
744,
860
]
} | 5,292 | |
Airdrop | Airdrop.sol | 0x5be8142fe5bfce520750c67fb2bf3a15be313b1a | Solidity | SafeMath | library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbe... | /**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/ | NatSpecMultiLine | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
| /**
* @dev Adds two numbers, throws on overflow.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://353555bc182defd75eb43996d232a0b02057c03a4cdfefbf58edfd7e6ea0f894 | {
"func_code_index": [
924,
1060
]
} | 5,293 | |
Airdrop | Airdrop.sol | 0x5be8142fe5bfce520750c67fb2bf3a15be313b1a | Solidity | Ownable | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
}
... | /**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| /**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://353555bc182defd75eb43996d232a0b02057c03a4cdfefbf58edfd7e6ea0f894 | {
"func_code_index": [
635,
816
]
} | 5,294 | |
Crowdsale | Crowdsale.sol | 0x9f06b7263a24c48f284c3e25c28dfd63cea24ac6 | Solidity | Freeze_contract | contract Freeze_contract is AESconstants {
function Freeze(address _address, uint _uint) private {
Account_frozen[_address] = _uint;
FrozenAccount_event(_address, _uint);
}
// mapping (address => uint) public frozenAccount;
// 0 NO FREEZE
// 1 Freeze onlyOwner
// 2 Freeze user
//Freeze u... | user_on_freeze | function user_on_freeze() public { require(Account_frozen[msg.sender]==0); Freeze(msg.sender,2); }
| // mapping (address => uint) public frozenAccount;
// 0 NO FREEZE
// 1 Freeze onlyOwner
// 2 Freeze user
//Freeze user //this is done to freeze your account. To avoid an attack: a block of dividend payments using spam transactions. | LineComment | v0.4.20-nightly.2018.1.22+commit.e5def2da | bzzr://14ae6876cdc362f5d54adde91d80645cff3d5c8ab77c6561d15a6c0df3bac7df | {
"func_code_index": [
438,
545
]
} | 5,295 | |||
Crowdsale | Crowdsale.sol | 0x9f06b7263a24c48f284c3e25c28dfd63cea24ac6 | Solidity | Freeze_contract | contract Freeze_contract is AESconstants {
function Freeze(address _address, uint _uint) private {
Account_frozen[_address] = _uint;
FrozenAccount_event(_address, _uint);
}
// mapping (address => uint) public frozenAccount;
// 0 NO FREEZE
// 1 Freeze onlyOwner
// 2 Freeze user
//Freeze u... | pay_Bounty | function pay_Bounty(address _address, uint _sum_pay ) onlyOwner public {
transfer(_address, _sum_pay);
Freeze(_address, 1);
}
| //Freeze used bounty company | LineComment | v0.4.20-nightly.2018.1.22+commit.e5def2da | bzzr://14ae6876cdc362f5d54adde91d80645cff3d5c8ab77c6561d15a6c0df3bac7df | {
"func_code_index": [
688,
820
]
} | 5,296 | |||
Crowdsale | Crowdsale.sol | 0x9f06b7263a24c48f284c3e25c28dfd63cea24ac6 | Solidity | AES_token_contract | contract AES_token_contract is Freeze_contract {
using SafeMath for uint;
uint public next_payout=now + 90 days;
uint public payout = 0; // Бюджет дивидентов
//--------Выплата доли
function Take_payout() public {
//Проверка можно ли пользователю запрашивать
require(Account_timePayout[msg.sender] < now);
/... | Take_payout | function Take_payout() public {
//Проверка можно ли пользователю запрашивать
require(Account_timePayout[msg.sender] < now);
//Проверка периода, если период прошел начисляем бюджет выплат
if(next_payout<now){
payout=this.balance;
next_payout=now + 90 days;
}
msg.sender.transfer(payout.mul(Account_balances... | // Бюджет дивидентов
//--------Выплата доли | LineComment | v0.4.20-nightly.2018.1.22+commit.e5def2da | bzzr://14ae6876cdc362f5d54adde91d80645cff3d5c8ab77c6561d15a6c0df3bac7df | {
"func_code_index": [
192,
599
]
} | 5,297 | |||
Crowdsale | Crowdsale.sol | 0x9f06b7263a24c48f284c3e25c28dfd63cea24ac6 | Solidity | Crowdsale | contract Crowdsale is Ownable {
address private multisig = msg.sender;
bool private share_team_AES=false;
using SafeMath for uint;
AES_token_contract public AEStoken = new AES_token_contract();
Hype public hype = new Hype(AEStoken);
BigHype public bighype = new BigHype(AEStoken);
uint pu... | Take_share_team_AES | function Take_share_team_AES() onlyOwner public {
require(share_team_AES == false);
AEStoken.transfer(multisig,500000);
share_team_AES=true;
}
| // 1518210000 - 10 February 2018
// Выплата команде и баунти | LineComment | v0.4.20-nightly.2018.1.22+commit.e5def2da | bzzr://14ae6876cdc362f5d54adde91d80645cff3d5c8ab77c6561d15a6c0df3bac7df | {
"func_code_index": [
425,
573
]
} | 5,298 | |||
Crowdsale | Crowdsale.sol | 0x9f06b7263a24c48f284c3e25c28dfd63cea24ac6 | Solidity | Crowdsale | contract Crowdsale is Ownable {
address private multisig = msg.sender;
bool private share_team_AES=false;
using SafeMath for uint;
AES_token_contract public AEStoken = new AES_token_contract();
Hype public hype = new Hype(AEStoken);
BigHype public bighype = new BigHype(AEStoken);
uint pu... | For_admin | function For_admin() onlyOwner public {
AEStoken.transferOwnership(multisig);
hype.transferOwnership(multisig);
bighype.transferOwnership(multisig);
}
| // старт | LineComment | v0.4.20-nightly.2018.1.22+commit.e5def2da | bzzr://14ae6876cdc362f5d54adde91d80645cff3d5c8ab77c6561d15a6c0df3bac7df | {
"func_code_index": [
586,
744
]
} | 5,299 | |||
Crowdsale | Crowdsale.sol | 0x9f06b7263a24c48f284c3e25c28dfd63cea24ac6 | Solidity | Crowdsale | contract Crowdsale is Ownable {
address private multisig = msg.sender;
bool private share_team_AES=false;
using SafeMath for uint;
AES_token_contract public AEStoken = new AES_token_contract();
Hype public hype = new Hype(AEStoken);
BigHype public bighype = new BigHype(AEStoken);
uint pu... | createTokens | function createTokens() isSaleTime private {
uint Tokens_on_Sale = AEStoken.balanceOf(this);
uint CenaTokena=1000000000000000; //1 finney= 1000 Szabo =0.002 Ether // 1000 Szabo= 1 finney
uint Discount=0;
// Скидка от остатка для распродажи
if(Tokens_... | // Всего 1 000 000 токенов AES
// 400 000 баунти 40%
// 100 000 команда проекта 10%
// 500 000 SALE IN ICO 50% | LineComment | v0.4.20-nightly.2018.1.22+commit.e5def2da | bzzr://14ae6876cdc362f5d54adde91d80645cff3d5c8ab77c6561d15a6c0df3bac7df | {
"func_code_index": [
1153,
3287
]
} | 5,300 | |||
EscapeOfficial | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0x4ecc242248993edb5c0aa0337677d5851e36c213 | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | name | function name() external view returns (string memory);
| /**
* @dev Returns the token collection name.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://cb01099678bee8c0f17e31bcbbc7a4a34709dd17835cecfd0304598570abde9a | {
"func_code_index": [
106,
165
]
} | 5,301 |
EscapeOfficial | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0x4ecc242248993edb5c0aa0337677d5851e36c213 | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | symbol | function symbol() external view returns (string memory);
| /**
* @dev Returns the token collection symbol.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://cb01099678bee8c0f17e31bcbbc7a4a34709dd17835cecfd0304598570abde9a | {
"func_code_index": [
236,
297
]
} | 5,302 |
EscapeOfficial | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0x4ecc242248993edb5c0aa0337677d5851e36c213 | Solidity | IERC721Metadata | interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev... | /**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/ | NatSpecMultiLine | tokenURI | function tokenURI(uint256 tokenId) external view returns (string memory);
| /**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://cb01099678bee8c0f17e31bcbbc7a4a34709dd17835cecfd0304598570abde9a | {
"func_code_index": [
398,
476
]
} | 5,303 |
EscapeOfficial | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0x4ecc242248993edb5c0aa0337677d5851e36c213 | Solidity | ERC721A | contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps trac... | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Assumes that an o... | NatSpecMultiLine | totalSupply | function totalSupply() public view override returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than _currentIndex times
unchecked {
return _currentIndex - _burnCounter;
}
}
| /**
* @dev See {IERC721Enumerable-totalSupply}.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://cb01099678bee8c0f17e31bcbbc7a4a34709dd17835cecfd0304598570abde9a | {
"func_code_index": [
2044,
2329
]
} | 5,304 |
EscapeOfficial | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0x4ecc242248993edb5c0aa0337677d5851e36c213 | Solidity | ERC721A | contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps trac... | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Assumes that an o... | NatSpecMultiLine | tokenByIndex | function tokenByIndex(uint256 index) public view override returns (uint256) {
uint256 numMintedSoFar = _currentIndex;
uint256 tokenIdsIdx;
// Counter overflow is impossible as the loop breaks when
// uint256 i is equal to another uint256 numMintedSoFar.
unchecked {
for (uint256 i; i ... | /**
* @dev See {IERC721Enumerable-tokenByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://cb01099678bee8c0f17e31bcbbc7a4a34709dd17835cecfd0304598570abde9a | {
"func_code_index": [
2617,
3335
]
} | 5,305 |
EscapeOfficial | @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol | 0x4ecc242248993edb5c0aa0337677d5851e36c213 | Solidity | ERC721A | contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using Address for address;
using Strings for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps trac... | /**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Assumes that an o... | NatSpecMultiLine | tokenOfOwnerByIndex | function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
if (index >= balanceOf(owner)) revert OwnerIndexOutOfBounds();
uint256 numMintedSoFar = _currentIndex;
uint256 tokenIdsIdx;
address currOwnershipAddr;
// Counter overflow is impossible as the l... | /**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/ | NatSpecMultiLine | v0.8.7+commit.e28d00a7 | GNU GPLv3 | ipfs://cb01099678bee8c0f17e31bcbbc7a4a34709dd17835cecfd0304598570abde9a | {
"func_code_index": [
3630,
4740
]
} | 5,306 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.