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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Fridgits | contracts/Fridgits.sol | 0x2112cc1f375f698ff0203243fe3eee7d5af969ae | Solidity | Fridgits | contract Fridgits is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmount = 100;
uint256 public ... | reveal | function reveal() public onlyOwner {
revealed = true;
}
| //only owner | LineComment | v0.8.7+commit.e28d00a7 | MIT | ipfs://4ce3c80292b1d2c0f518b760e06a8e46e92f8c5eb4d9450f122a9749f7204d1f | {
"func_code_index": [
3184,
3258
]
} | 5,900 | ||
EXODUS2 | ERC165Checker.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | Solidity | ERC165Checker | library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*... | /**
* @title ERC165Checker
* @dev Use `using ERC165Checker for address`; to include this library
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
*/ | NatSpecMultiLine | _supportsERC165 | function _supportsERC165(address account) internal view returns (bool) {
// Any contract that implements ERC165 must explicitly indicate support of
// InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
return _supportsERC165Interface(account, _INTERFACE_ID_ERC165) &&
!_sup... | /**
* @notice Query if a contract supports ERC165
* @param account The address of the contract to query for support of ERC165
* @return true if the contract at account implements ERC165
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
536,
935
]
} | 5,901 |
EXODUS2 | ERC165Checker.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | Solidity | ERC165Checker | library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*... | /**
* @title ERC165Checker
* @dev Use `using ERC165Checker for address`; to include this library
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
*/ | NatSpecMultiLine | _supportsInterface | function _supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
// query support of both ERC165 as per the spec and support of _interfaceId
return _supportsERC165(account) &&
_supportsERC165Interface(account, interfaceId);
}
| /**
* @notice Query if a contract implements an interface, also checks support of ERC165
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return true if the contract at account indicates support of the interfa... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
1402,
1694
]
} | 5,902 |
EXODUS2 | ERC165Checker.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | Solidity | ERC165Checker | library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*... | /**
* @title ERC165Checker
* @dev Use `using ERC165Checker for address`; to include this library
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
*/ | NatSpecMultiLine | _supportsAllInterfaces | function _supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
// query support of ERC165 itself
if (!_supportsERC165(account)) {
return false;
}
// query support of each interface in _interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i... | /**
* @notice Query if a contract implements interfaces, also checks support of ERC165
* @param account The address of the contract to query for support of an interface
* @param interfaceIds A list of interface identifiers, as specified in ERC-165
* @return true if the contract at account indicates support all inte... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
2162,
2704
]
} | 5,903 |
EXODUS2 | ERC165Checker.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | Solidity | ERC165Checker | library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*... | /**
* @title ERC165Checker
* @dev Use `using ERC165Checker for address`; to include this library
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
*/ | NatSpecMultiLine | _supportsERC165Interface | function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {
// success determines whether the staticcall succeeded and result determines
// whether the contract at account indicates support of _interfaceId
(bool success, bool result) = _callERC165SupportsInterface(ac... | /**
* @notice Query if a contract implements an interface, does not check ERC165 support
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return true if the contract at account indicates support of the interfa... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
3390,
3789
]
} | 5,904 |
EXODUS2 | ERC165Checker.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | Solidity | ERC165Checker | library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*... | /**
* @title ERC165Checker
* @dev Use `using ERC165Checker for address`; to include this library
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
*/ | NatSpecMultiLine | _callERC165SupportsInterface | function _callERC165SupportsInterface(address account, bytes4 interfaceId)
private
view
returns (bool success, bool result)
{
bytes memory encodedParams = abi.encodeWithSelector(_INTERFACE_ID_ERC165, interfaceId);
// solhint-disable-next-line no-inline-assembly
assembly {
let encodedPar... | /**
* @notice Calls the function with selector 0x01ffc9a7 (ERC165) and suppresses throw
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return success true if the STATICCALL succeeded, false otherwise
* @ret... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
4302,
5322
]
} | 5,905 |
EXODUS2 | ERC721Mintable.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | Solidity | ERC721Mintable | contract ERC721Mintable is ERC721, MinterRole {
/**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param tokenId The token id to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address to, uint256... | /**
* @title ERC721Mintable
* @dev ERC721 minting logic
*/ | NatSpecMultiLine | mint | function mint(address to, uint256 tokenId) public onlyMinter returns (bool) {
_mint(to, tokenId);
return true;
}
| /**
* @dev Function to mint tokens
* @param to The address that will receive the minted tokens.
* @param tokenId The token id to mint.
* @return A boolean that indicates if the operation was successful.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
283,
419
]
} | 5,906 |
EXODUS2 | ERC721Burnable.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | Solidity | ERC721Burnable | contract ERC721Burnable is ERC721 {
/**
* @dev Burns a specific ERC721 token.
* @param tokenId uint256 id of the ERC721 token to be burned.
*/
function burn(uint256 tokenId) public {
require(_isApprovedOrOwner(msg.sender, tokenId));
_burn(tokenId);
}
} | /**
* @title ERC721 Burnable Token
* @dev ERC721 Token that can be irreversibly burned (destroyed).
*/ | NatSpecMultiLine | burn | function burn(uint256 tokenId) public {
require(_isApprovedOrOwner(msg.sender, tokenId));
_burn(tokenId);
}
| /**
* @dev Burns a specific ERC721 token.
* @param tokenId uint256 id of the ERC721 token to be burned.
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
162,
293
]
} | 5,907 |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Buffer | library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
// Allocate space for the buffer data
b... | /*
Begin solidity-cborutils
https://github.com/smartcontractkit/solidity-cborutils
MIT License
Copyright (c) 2018 SmartContract ChainLink, Ltd.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to de... | Comment | append | function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
// Memory address of the bu... | /**
* @dev Appends a byte array to the end of the buffer. Resizes if doing so
* would exceed the capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @return The original buffer.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
1123,
2417
]
} | 5,908 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Buffer | library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
// Allocate space for the buffer data
b... | /*
Begin solidity-cborutils
https://github.com/smartcontractkit/solidity-cborutils
MIT License
Copyright (c) 2018 SmartContract ChainLink, Ltd.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to de... | Comment | append | function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
// Memory address of the buffer data
let bufptr := mload(buf)
// Length of existing buffer data
let buflen := m... | /**
* @dev Appends a byte to the end of the buffer. Resizes if doing so would
* exceed the capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @return The original buffer.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
2682,
3318
]
} | 5,909 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Buffer | library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
// Allocate space for the buffer data
b... | /*
Begin solidity-cborutils
https://github.com/smartcontractkit/solidity-cborutils
MIT License
Copyright (c) 2018 SmartContract ChainLink, Ltd.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to de... | Comment | appendInt | function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
// Memory address of the buffer data
let bufptr :... | /**
* @dev Appends a byte to the end of the buffer. Resizes if doing so would
* exceed the capacity of the buffer.
* @param buf The buffer to append to.
* @param data The data to append.
* @return The original buffer.
*/ | NatSpecMultiLine | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
3583,
4365
]
} | 5,910 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | usingOraclize | contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
... | /*
End solidity-cborutils
*/ | Comment | parseInt | function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
| // parseInt | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
27483,
27587
]
} | 5,911 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | usingOraclize | contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
... | /*
End solidity-cborutils
*/ | Comment | parseInt | function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
... | // parseInt(parseFloat*10^_b) | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
27625,
28239
]
} | 5,912 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | usingOraclize | contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
... | /*
End solidity-cborutils
*/ | Comment | copyBytes | function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
// Buffer too small
require(to.length >= minLength); // Should be a better way?
// NOTE: the offset 32 is added to skip the `size` field of bo... | // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
38942,
39633
]
} | 5,913 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | usingOraclize | contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
... | /*
End solidity-cborutils
*/ | Comment | safer_ecrecover | function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
// We do our own memory management here. Solidity uses memory offset
// 0x40 to store the current end of memory. We write past it (as
// writes are memory extensions), but don't update the offset so
... | // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
// Duplicate Solidity's ecrecover, but catching the CALL return value | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
39830,
40833
]
} | 5,914 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | usingOraclize | contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
... | /*
End solidity-cborutils
*/ | Comment | ecrecovery | function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
// The signature format is a compact form of:
// {bytes32 r}{bytes32 s}{uint8 v}
// Compact means, uint8 is not padded t... | // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
40955,
42381
]
} | 5,915 | |
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Crowdsale | contract Crowdsale is usingOraclize {
using SafeMath for uint256;
// address where funds are collected
address public wallet;
// token address
address public addressOfTokenUsedAsReward;
token tokenReward;
// amount of raised money in wei
uint256 public weiRaised;
uint public price = 1... | setPrice | function setPrice(uint _price) public {
require (msg.sender == wallet && _price != 0);
price = _price;
}
| // one token = _price cents | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
1409,
1529
]
} | 5,916 | |||
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Crowdsale | contract Crowdsale is usingOraclize {
using SafeMath for uint256;
// address where funds are collected
address public wallet;
// token address
address public addressOfTokenUsedAsReward;
token tokenReward;
// amount of raised money in wei
uint256 public weiRaised;
uint public price = 1... | function () public payable {
buyTokens(msg.sender);
}
| // fallback function can be used to buy tokens | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
1582,
1646
]
} | 5,917 | ||||
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Crowdsale | contract Crowdsale is usingOraclize {
using SafeMath for uint256;
// address where funds are collected
address public wallet;
// token address
address public addressOfTokenUsedAsReward;
token tokenReward;
// amount of raised money in wei
uint256 public weiRaised;
uint public price = 1... | buyTokens | function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// update state
weiRaised = weiRaised.add(weiAmount);
emit newOraclizeQuery("Oraclize query was sent, standing by for the answer..");
bytes32 qu... | // low level token purchase function | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
2284,
2852
]
} | 5,918 | |||
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Crowdsale | contract Crowdsale is usingOraclize {
using SafeMath for uint256;
// address where funds are collected
address public wallet;
// token address
address public addressOfTokenUsedAsReward;
token tokenReward;
// amount of raised money in wei
uint256 public weiRaised;
uint public price = 1... | forwardFunds | function forwardFunds() internal {
wallet.transfer(address(this).balance);
}
| // send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
2961,
3048
]
} | 5,919 | |||
Crowdsale | Crowdsale.sol | 0x9eb409a840c90aa26ac4dca5cd29b20720fdf078 | Solidity | Crowdsale | contract Crowdsale is usingOraclize {
using SafeMath for uint256;
// address where funds are collected
address public wallet;
// token address
address public addressOfTokenUsedAsReward;
token tokenReward;
// amount of raised money in wei
uint256 public weiRaised;
uint public price = 1... | validPurchase | function validPurchase() internal constant returns (bool) {
bool withinPeriod = started;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
| // @return true if the transaction can buy tokens | LineComment | v0.4.24+commit.e67f0147 | bzzr://36985f8c3c897e5c47572c4524a335afc46ce0d1fd4bd5bc8dc870f1a285c8fb | {
"func_code_index": [
3104,
3294
]
} | 5,920 | |||
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | 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.
*/
function Ownable() 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 | Ownable | function Ownable() public {
owner = msg.sender;
}
| /**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
261,
321
]
} | 5,921 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | 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.
*/
function Ownable() 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.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
640,
821
]
} | 5,922 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | Whitelist | contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
require(whitelist[msg.... | /**
* @title Whitelist
* @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions.
* @dev This simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | addAddressToWhitelist | function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
| /**
* @dev add an address to the whitelist
* @param addr address
* @return true if the address was added to the whitelist, false if the address was already in the whitelist
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
541,
767
]
} | 5,923 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | Whitelist | contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
require(whitelist[msg.... | /**
* @title Whitelist
* @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions.
* @dev This simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | addAddressesToWhitelist | function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
| /**
* @dev add addresses to the whitelist
* @param addrs addresses
* @return true if at least one address was added to the whitelist,
* false if all addresses were already in the whitelist
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
985,
1220
]
} | 5,924 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | Whitelist | contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
require(whitelist[msg.... | /**
* @title Whitelist
* @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions.
* @dev This simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | removeAddressFromWhitelist | function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
| /**
* @dev remove an address from the whitelist
* @param addr address
* @return true if the address was removed from the whitelist,
* false if the address wasn't in the whitelist in the first place
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
1447,
1680
]
} | 5,925 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | Whitelist | contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
require(whitelist[msg.... | /**
* @title Whitelist
* @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions.
* @dev This simplifies the implementation of "user permissions".
*/ | NatSpecMultiLine | removeAddressesFromWhitelist | function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
| /**
* @dev remove addresses from the whitelist
* @param addrs addresses
* @return true if at least one address was removed from the whitelist,
* false if all addresses weren't in the whitelist in the first place
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
1921,
2166
]
} | 5,926 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function ... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | pause | function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
| /**
* @dev called by the owner to pause, triggers stopped state
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
513,
609
]
} | 5,927 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | Pausable | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function ... | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/ | NatSpecMultiLine | unpause | function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
| /**
* @dev called by the owner to unpause, returns to normal state
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
693,
791
]
} | 5,928 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | BuyLimits | contract BuyLimits {
event LogLimitsChanged(uint _minBuy, uint _maxBuy);
// Variables holding the min and max payment in wei
uint public minBuy; // min buy in wei
uint public maxBuy; // max buy in wei, 0 means no maximum
/*
** Modifier, reverting if not within limits.
*/
modi... | BuyLimits | function BuyLimits(uint _min, uint _max) public {
_setLimits(_min, _max);
}
| /*
** @dev Constructor, define variable:
*/ | Comment | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
478,
573
]
} | 5,929 | |||
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | BuyLimits | contract BuyLimits {
event LogLimitsChanged(uint _minBuy, uint _maxBuy);
// Variables holding the min and max payment in wei
uint public minBuy; // min buy in wei
uint public maxBuy; // max buy in wei, 0 means no maximum
/*
** Modifier, reverting if not within limits.
*/
modi... | withinLimits | function withinLimits(uint _value) public view returns(bool) {
if (maxBuy != 0) {
return (_value >= minBuy && _value <= maxBuy);
}
return (_value >= minBuy);
}
| /*
** @dev Check TXs value is within limits:
*/ | Comment | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
639,
848
]
} | 5,930 | |||
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | BuyLimits | contract BuyLimits {
event LogLimitsChanged(uint _minBuy, uint _maxBuy);
// Variables holding the min and max payment in wei
uint public minBuy; // min buy in wei
uint public maxBuy; // max buy in wei, 0 means no maximum
/*
** Modifier, reverting if not within limits.
*/
modi... | _setLimits | function _setLimits(uint _min, uint _max) internal {
if (_max != 0) {
require (_min <= _max); // Sanity Check
}
minBuy = _min;
maxBuy = _max;
emit LogLimitsChanged(_min, _max);
}
| /*
** @dev set limits logic:
** @param _min set the minimum buy in wei
** @param _max set the maximum buy in wei, 0 indeicates no maximum
*/ | Comment | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
1017,
1263
]
} | 5,931 | |||
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | DAOstackPreSale | contract DAOstackPreSale is Pausable,BuyLimits,Whitelist {
event LogFundsReceived(address indexed _sender, uint _amount);
address public wallet;
/**
* @dev Constructor.
* @param _wallet Address where the funds are transfered to
* @param _minBuy Address where the funds are transfered to... | /**
* @title DAOstackPresale
* @dev A contract to allow only whitelisted followers to participate in presale.
*/ | NatSpecMultiLine | DAOstackPreSale | function DAOstackPreSale(address _wallet, uint _minBuy, uint _maxBuy)
public
BuyLimits(_minBuy, _maxBuy)
{
// Set wallet:
require(_wallet != address(0));
wallet = _wallet;
}
| /**
* @dev Constructor.
* @param _wallet Address where the funds are transfered to
* @param _minBuy Address where the funds are transfered to
* @param _maxBuy Address where the funds are transfered to
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
394,
619
]
} | 5,932 | |
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | DAOstackPreSale | contract DAOstackPreSale is Pausable,BuyLimits,Whitelist {
event LogFundsReceived(address indexed _sender, uint _amount);
address public wallet;
/**
* @dev Constructor.
* @param _wallet Address where the funds are transfered to
* @param _minBuy Address where the funds are transfered to... | /**
* @title DAOstackPresale
* @dev A contract to allow only whitelisted followers to participate in presale.
*/ | NatSpecMultiLine | function () payable whenNotPaused onlyWhitelisted isWithinLimits(msg.value) external {
wallet.transfer(msg.value);
emit LogFundsReceived(msg.sender, msg.value);
}
| /**
* @dev Fallback, funds coming in are transfered to wallet
*/ | NatSpecMultiLine | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
702,
892
]
} | 5,933 | ||
DAOstackPreSale | DAOstackPreSale.sol | 0x946312616cba7d41e6307e9e7fc16250a470307e | Solidity | DAOstackPreSale | contract DAOstackPreSale is Pausable,BuyLimits,Whitelist {
event LogFundsReceived(address indexed _sender, uint _amount);
address public wallet;
/**
* @dev Constructor.
* @param _wallet Address where the funds are transfered to
* @param _minBuy Address where the funds are transfered to... | /**
* @title DAOstackPresale
* @dev A contract to allow only whitelisted followers to participate in presale.
*/ | NatSpecMultiLine | drain | function drain() external {
wallet.transfer((address(this)).balance);
}
| /*
** @dev Drain function, in case of failure. Contract should not hold eth anyhow.
*/ | Comment | v0.4.21+commit.dfe3193c | bzzr://88bd35f3a9c7f39d41701afbb62f0c0c148b318ce67cae9c6e544a0ced526e09 | {
"func_code_index": [
997,
1087
]
} | 5,934 | |
EXODUS2 | IERC721Receiver.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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
* ret... | /**
* @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 memory 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.onERC721Received.sel... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
878,
1004
]
} | 5,935 |
PropertyFactory | contracts/src/property/Property.sol | 0x8a2c73f4d243f35ad62fc651302b742e0b3fa96c | Solidity | Property | contract Property is ERC20, ERC20Detailed, UsingConfig, IProperty {
using SafeMath for uint256;
uint8 private constant PROPERTY_DECIMALS = 18;
uint256 private constant SUPPLY = 10000000000000000000000000;
address public author;
/**
* Initializes the passed value as AddressConfig address, author address, ... | /**
* A contract that represents the assets of the user and collects staking from the stakers.
* Property contract inherits ERC20.
* Holders of Property contracts(tokens) receive holder rewards according to their share.
*/ | NatSpecMultiLine | transfer | function transfer(address _to, uint256 _value) public returns (bool) {
/**
* Validates the destination is not 0 address.
*/
require(_to != address(0), "this is illegal address");
require(_value != 0, "illegal transfer value");
/**
* Calls Withdraw contract via Allocator contract.
* Passing through... | /**
* Hook on `transfer` and call `Withdraw.beforeBalanceChange` function.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | MPL-2.0 | bzzr://07adc538be83a7033ae59daa76abe29e0800df39dc029e9c7485468371a7d2fe | {
"func_code_index": [
1199,
1838
]
} | 5,936 |
PropertyFactory | contracts/src/property/Property.sol | 0x8a2c73f4d243f35ad62fc651302b742e0b3fa96c | Solidity | Property | contract Property is ERC20, ERC20Detailed, UsingConfig, IProperty {
using SafeMath for uint256;
uint8 private constant PROPERTY_DECIMALS = 18;
uint256 private constant SUPPLY = 10000000000000000000000000;
address public author;
/**
* Initializes the passed value as AddressConfig address, author address, ... | /**
* A contract that represents the assets of the user and collects staking from the stakers.
* Property contract inherits ERC20.
* Holders of Property contracts(tokens) receive holder rewards according to their share.
*/ | NatSpecMultiLine | transferFrom | function transferFrom(
address _from,
address _to,
uint256 _value
) public returns (bool) {
/**
* Validates the source and destination is not 0 address.
*/
require(_from != address(0), "this is illegal address");
require(_to != address(0), "this is illegal address");
require(_value != 0, "illegal t... | /**
* Hook on `transferFrom` and call `Withdraw.beforeBalanceChange` function.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | MPL-2.0 | bzzr://07adc538be83a7033ae59daa76abe29e0800df39dc029e9c7485468371a7d2fe | {
"func_code_index": [
1931,
2912
]
} | 5,937 |
PropertyFactory | contracts/src/property/Property.sol | 0x8a2c73f4d243f35ad62fc651302b742e0b3fa96c | Solidity | Property | contract Property is ERC20, ERC20Detailed, UsingConfig, IProperty {
using SafeMath for uint256;
uint8 private constant PROPERTY_DECIMALS = 18;
uint256 private constant SUPPLY = 10000000000000000000000000;
address public author;
/**
* Initializes the passed value as AddressConfig address, author address, ... | /**
* A contract that represents the assets of the user and collects staking from the stakers.
* Property contract inherits ERC20.
* Holders of Property contracts(tokens) receive holder rewards according to their share.
*/ | NatSpecMultiLine | withdraw | function withdraw(address _sender, uint256 _value) external {
/**
* Validates the sender is Lockup contract.
*/
require(msg.sender == config().lockup(), "this is illegal address");
/**
* Transfers the passed amount to the original owner.
*/
ERC20 devToken = ERC20(config().token());
bool result =... | /**
* Transfers the staking amount to the original owner.
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | MPL-2.0 | bzzr://07adc538be83a7033ae59daa76abe29e0800df39dc029e9c7485468371a7d2fe | {
"func_code_index": [
2984,
3398
]
} | 5,938 |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | ERC20Interface | contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() constant returns(uint256 supply);
function balanceOf(address _owner) constant returns(uint256 bala... | decimals | function decimals() constant returns(uint8);
| // function symbol() constant returns(string); | LineComment | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
724,
773
]
} | 5,939 | |||
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | init | function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
| /**
* Sets EToken2 address, assigns symbol and name.
*
* Can be set only once.
*
* @param _etoken2 EToken2 contract address.
* @param _symbol assigned symbol.
* @param _name assigned name.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
602,
923
]
} | 5,940 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | _getAsset | function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
| /**
* Returns asset implementation contract for current caller.
*
* @return asset implementation contract.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
1436,
1562
]
} | 5,941 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | totalSupply | function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
| /**
* Returns asset total supply.
*
* @return asset total supply.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
1829,
1940
]
} | 5,942 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | balanceOf | function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
| /**
* Returns asset balance for a particular holder.
*
* @param _owner holder address.
*
* @return holder balance.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
2102,
2231
]
} | 5,943 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | allowance | function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
| /**
* Returns asset allowance from one holder to another.
*
* @param _from holder that allowed spending.
* @param _spender holder that is allowed to spend.
*
* @return holder to spender allowance.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
2481,
2636
]
} | 5,944 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | decimals | function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
| /**
* Returns asset decimals.
*
* @return asset decimals.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
2729,
2835
]
} | 5,945 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transfer | function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
| /**
* Transfers asset balance from the caller to specified receiver.
*
* @param _to holder address to give to.
* @param _value amount to transfer.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
3056,
3183
]
} | 5,946 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferWithReference | function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
| /**
* Transfers asset balance from the caller to specified receiver adding specified comment.
* Resolves asset implementation contract for the caller and forwards there arguments along with
* the caller address.
*
* @param _to holder address to give to.
* @param _value amount to transfer.
* @param _refere... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
3648,
3847
]
} | 5,947 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferToICAP | function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
| /**
* Transfers asset balance from the caller to specified ICAP.
*
* @param _icap recipient ICAP to give to.
* @param _value amount to transfer.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
4066,
4209
]
} | 5,948 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferToICAPWithReference | function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
| /**
* Transfers asset balance from the caller to specified ICAP adding specified comment.
* Resolves asset implementation contract for the caller and forwards there arguments along with
* the caller address.
*
* @param _icap recipient ICAP to give to.
* @param _value amount to transfer.
* @param _referenc... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
4672,
4887
]
} | 5,949 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferFrom | function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
| /**
* Prforms allowance transfer of asset balance between holders.
*
* @param _from holder address to take from.
* @param _to holder address to give to.
* @param _value amount to transfer.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
5156,
5313
]
} | 5,950 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferFromWithReference | function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
| /**
* Prforms allowance transfer of asset balance between holders adding specified comment.
* Resolves asset implementation contract for the caller and forwards there arguments along with
* the caller address.
*
* @param _from holder address to take from.
* @param _to holder address to give to.
* @param _... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
5826,
6055
]
} | 5,951 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | _forwardTransferFromWithReference | function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
| /**
* Performs transfer call on the EToken2 by the name of specified sender.
*
* Can only be called by asset implementation contract assigned to sender.
*
* @param _from holder address to take from.
* @param _to holder address to give to.
* @param _value amount to transfer.
* @param _reference transfer ... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
6550,
6840
]
} | 5,952 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferFromToICAP | function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
| /**
* Prforms allowance transfer of asset balance between holders.
*
* @param _from holder address to take from.
* @param _icap recipient ICAP address to give to.
* @param _value amount to transfer.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
7119,
7292
]
} | 5,953 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferFromToICAPWithReference | function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
| /**
* Prforms allowance transfer of asset balance between holders adding specified comment.
* Resolves asset implementation contract for the caller and forwards there arguments along with
* the caller address.
*
* @param _from holder address to take from.
* @param _icap recipient ICAP address to give to.
... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
7815,
8060
]
} | 5,954 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | _forwardTransferFromToICAPWithReference | function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
| /**
* Performs allowance transfer to ICAP call on the EToken2 by the name of specified sender.
*
* Can only be called by asset implementation contract assigned to sender.
*
* @param _from holder address to take from.
* @param _icap recipient ICAP address to give to.
* @param _value amount to transfer.
*... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
8583,
8874
]
} | 5,955 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | approve | function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
| /**
* Sets asset spending allowance for a specified spender.
* Resolves asset implementation contract for the caller and forwards there arguments along with
* the caller address.
*
* @param _spender holder address to set allowance to.
* @param _value amount to allow.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
9228,
9378
]
} | 5,956 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | _forwardApprove | function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
| /**
* Performs allowance setting call on the EToken2 by the name of specified sender.
*
* Can only be called by asset implementation contract assigned to sender.
*
* @param _spender holder address to set allowance to.
* @param _value amount to allow.
* @param _sender initial caller.
*
* @return succes... | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
9754,
9965
]
} | 5,957 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | emitTransfer | function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
| /**
* Emits ERC20 Transfer event on this contract.
*
* Can only be, and, called by assigned EToken2 when asset transfer happens.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
10129,
10258
]
} | 5,958 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | emitApprove | function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
| /**
* Emits ERC20 Approval event on this contract.
*
* Can only be, and, called by assigned EToken2 when asset allowance set happens.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
10427,
10565
]
} | 5,959 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
| /**
* Resolves asset implementation contract for the caller and forwards there transaction data,
* along with the value. This allows for proxy interface growth.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
10755,
10899
]
} | 5,960 | ||
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | transferToICAP | function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
| // Interface functions to allow specifying ICAP addresses as strings. | LineComment | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
10977,
11119
]
} | 5,961 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | getVersionFor | function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
| /**
* Returns asset implementation contract address assigned to sender.
*
* @param _sender sender address.
*
* @return asset implementation contract address.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
12884,
13057
]
} | 5,962 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | getLatestVersion | function getLatestVersion() constant returns(address) {
return latestVersion;
}
| /**
* Returns current asset implementation contract address.
*
* @return asset implementation contract address.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
13204,
13302
]
} | 5,963 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | getPendingVersion | function getPendingVersion() constant returns(address) {
return pendingVersion;
}
| /**
* Returns proposed next asset implementation contract address.
*
* @return asset implementation contract address.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
13455,
13555
]
} | 5,964 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | getPendingVersionTimestamp | function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
| /**
* Returns upgrade freeze-time start.
*
* @return freeze-time start.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
13662,
13777
]
} | 5,965 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | proposeUpgrade | function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
// Should not already be in the upgrading process.
if (pendingVersion != 0x0) {
return false;
}
// New version address should be other than 0x0.
if (_newVersion == 0x0) {
return false;
}
//... | /**
* Propose next asset implementation contract address.
*
* Can only be called by current asset owner.
*
* Note: freeze-time should not be applied for the initial setup.
*
* @param _newVersion asset implementation contract address.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
14103,
14774
]
} | 5,966 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | purgeUpgrade | function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
| /**
* Cancel the pending upgrade process.
*
* Can only be called by current asset owner.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
14931,
15170
]
} | 5,967 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | commitUpgrade | function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
... | /**
* Finalize an upgrade process setting new asset implementation contract address.
*
* Can only be called after an upgrade freeze-time.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
15376,
15746
]
} | 5,968 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | optOut | function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
return true;
}
| /**
* Disagree with proposed upgrade, and stick with current asset implementation
* until further explicit agreement to upgrade.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
15937,
16151
]
} | 5,969 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | optIn | function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
return true;
}
| /**
* Implicitly agree to upgrade to current and future asset implementation upgrades,
* until further explicit disagreement.
*
* @return success.
*/ | NatSpecMultiLine | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
16339,
16452
]
} | 5,970 | |
REMME | REMME.sol | 0x83984d6142934bb535793a82adb0a46ef0f66b6d | Solidity | REMME | contract REMME is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;... | /**
* @title EToken2 Asset Proxy.
*
* Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
* Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
* Every request that is made by caller first sent to the specific asset implementation
* contract, which ... | NatSpecMultiLine | multiAsset | function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
| // Backwards compatibility. | LineComment | v0.4.15+commit.bbb8e64f | bzzr://b63519aefab850441fb9213a9c60c38a9226690754cd394c422c3ed96d0e3dff | {
"func_code_index": [
16488,
16583
]
} | 5,971 | |
EXODUS2 | strings.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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))
}
... | 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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
831,
1045
]
} | 5,972 | ||
EXODUS2 | strings.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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))
}
... | 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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
1328,
1707
]
} | 5,973 | ||
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
1814,
1968
]
} | 5,974 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
2188,
2369
]
} | 5,975 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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 token I... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
2786,
3082
]
} | 5,976 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
3363,
3518
]
} | 5,977 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
3806,
4023
]
} | 5,978 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
4340,
4489
]
} | 5,979 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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));
_transferFrom(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 the giv... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
4918,
5102
]
} | 5,980 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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 {
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,
* the... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
5737,
5873
]
} | 5,981 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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 memory _data) public {
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(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,
* the... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
6574,
6789
]
} | 5,982 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
6974,
7130
]
} | 5,983 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, 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 the t... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
7489,
7739
]
} | 5,984 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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));
require(!_exists(tokenId));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
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
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
7978,
8260
]
} | 5,985 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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 {
require(ownerOf(tokenId) == owner);
_clearApproval(tokenId);
_ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
| /**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* Deprecated, use _burn(uint256) instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
8529,
8838
]
} | 5,986 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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(uint256 tokenId) internal {
_burn(ownerOf(tokenId), 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
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
9013,
9107
]
} | 5,987 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
_tokenOwner[token... | /**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to transferFrom, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token t... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
9477,
9883
]
} | 5,988 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/ | NatSpecMultiLine | _checkOnERC721Received | function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
| /**
* @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 the tok... | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
10402,
10753
]
} | 5,989 |
EXODUS2 | ERC721.sol | 0x76e422de0ce8842ebe837bc7ab6984b4fff88055 | 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 = ... | /**
* @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(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
| /**
* @dev Private function to clear current approval of a given token ID
* @param tokenId uint256 ID of the token to be transferred
*/ | NatSpecMultiLine | v0.5.0+commit.1d4f565a | MIT | bzzr://4dc56cdfb144f689c22393e93357ad564cda72fe3ce195f496cd46ea489767e6 | {
"func_code_index": [
10910,
11085
]
} | 5,990 |
BancorConverter | contracts/token/interfaces/IERC20Token.sol | 0x52e37cd16197a9b33529c5c7c7d134a56bd53f71 | Solidity | IERC20Token | contract IERC20Token {
// these functions aren't abstract since the compiler emits automatically generated getter functions as external
function name() public view returns (string) {this;}
function symbol() public view returns (string) {this;}
function decimals() public view returns (uint8) {this;}
... | /*
ERC20 Standard Token interface
*/ | Comment | name | function name() public view returns (string) {this;}
| // these functions aren't abstract since the compiler emits automatically generated getter functions as external | LineComment | v0.4.26+commit.4563c3fc | bzzr://a1d5240c498906975038de9bdb52dacf0a95be608af2600ce15c20774b5be07a | {
"func_code_index": [
140,
196
]
} | 5,991 | |
SSC | SSC.sol | 0x293cb32ccdbe33c28372b4ebafcb9bb2e293a3ad | Solidity | SSC | contract SSC {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | _transfer | function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balan... | /**
* Internal transfer, only can be called by this contract
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://0e95eabed09004ef760dac8df0a5f5913771d85ea66a677642ec09917c217d4f | {
"func_code_index": [
1643,
2500
]
} | 5,992 | ||
SSC | SSC.sol | 0x293cb32ccdbe33c28372b4ebafcb9bb2e293a3ad | Solidity | SSC | contract SSC {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | transfer | function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
| /**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://0e95eabed09004ef760dac8df0a5f5913771d85ea66a677642ec09917c217d4f | {
"func_code_index": [
2706,
2863
]
} | 5,993 | ||
SSC | SSC.sol | 0x293cb32ccdbe33c28372b4ebafcb9bb2e293a3ad | Solidity | SSC | contract SSC {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | transferFrom | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
| /**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://0e95eabed09004ef760dac8df0a5f5913771d85ea66a677642ec09917c217d4f | {
"func_code_index": [
3138,
3439
]
} | 5,994 | ||
SSC | SSC.sol | 0x293cb32ccdbe33c28372b4ebafcb9bb2e293a3ad | Solidity | SSC | contract SSC {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | approve | function approve(address _spender, uint256 _value) public
returns (bool success) {
require((_value == 0) || (allowance[msg.sender][_spender] == 0));
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| /**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/ | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://0e95eabed09004ef760dac8df0a5f5913771d85ea66a677642ec09917c217d4f | {
"func_code_index": [
3703,
4008
]
} | 5,995 | ||
SSC | SSC.sol | 0x293cb32ccdbe33c28372b4ebafcb9bb2e293a3ad | Solidity | SSC | contract SSC {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => u... | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true... | /**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to s... | NatSpecMultiLine | v0.5.17+commit.d19bba13 | None | bzzr://0e95eabed09004ef760dac8df0a5f5913771d85ea66a677642ec09917c217d4f | {
"func_code_index": [
4402,
4770
]
} | 5,996 | ||
TokenERC20 | TokenERC20.sol | 0xc608342e743ec99b2839aa3bc97f6f78791bd3fb | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;... | add | function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
| /**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/ | NatSpecMultiLine | v0.4.26+commit.4563c3fc | None | bzzr://9c8eac2a7c7305a20d7019abb8bbb51e4e8952418577898a4d5290bfc6451850 | {
"func_code_index": [
229,
389
]
} | 5,997 | ||
TokenERC20 | TokenERC20.sol | 0xc608342e743ec99b2839aa3bc97f6f78791bd3fb | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;... | sub | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.4.26+commit.4563c3fc | None | bzzr://9c8eac2a7c7305a20d7019abb8bbb51e4e8952418577898a4d5290bfc6451850 | {
"func_code_index": [
637,
766
]
} | 5,998 | ||
TokenERC20 | TokenERC20.sol | 0xc608342e743ec99b2839aa3bc97f6f78791bd3fb | Solidity | SafeMath | library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;... | sub | function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
| /**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/ | NatSpecMultiLine | v0.4.26+commit.4563c3fc | None | bzzr://9c8eac2a7c7305a20d7019abb8bbb51e4e8952418577898a4d5290bfc6451850 | {
"func_code_index": [
1034,
1218
]
} | 5,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.