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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
AccessControlledAggregator | AccessControlledAggregator.sol | 0xb8169f6d97c66c50ef27b7b1b3fb2875d2b036a4 | Solidity | AccessControlledAggregator | contract AccessControlledAggregator is FluxAggregator, SimpleReadAccessController {
/**
* @notice set up the aggregator with initial configuration
* @param _link The address of the LINK token
* @param _paymentAmount The amount paid of LINK paid to each oracle per submission, in wei (units of 10⁻¹⁸ LINK)
* @param _timeout is the number of seconds after the previous round that are
* allowed to lapse before allowing an oracle to skip an unfinished round
* @param _validator is an optional contract address for validating
* external validation of answers
* @param _minSubmissionValue is an immutable check for a lower bound of what
* submission values are accepted from an oracle
* @param _maxSubmissionValue is an immutable check for an upper bound of what
* submission values are accepted from an oracle
* @param _decimals represents the number of decimals to offset the answer by
* @param _description a short description of what is being reported
*/
constructor(
address _link,
uint128 _paymentAmount,
uint32 _timeout,
address _validator,
int256 _minSubmissionValue,
int256 _maxSubmissionValue,
uint8 _decimals,
string memory _description
) public FluxAggregator(
_link,
_paymentAmount,
_timeout,
_validator,
_minSubmissionValue,
_maxSubmissionValue,
_decimals,
_description
){}
/**
* @notice get data about a round. Consumers are encouraged to check
* that they're receiving fresh data by inspecting the updatedAt and
* answeredInRound return values.
* @param _roundId the round ID to retrieve the round data for
* @return roundId is the round ID for which data was retrieved
* @return answer is the answer for the given round
* @return startedAt is the timestamp when the round was started. This is 0
* if the round hasn't been started yet.
* @return updatedAt is the timestamp when the round last was updated (i.e.
* answer was last computed)
* @return answeredInRound is the round ID of the round in which the answer
* was computed. answeredInRound may be smaller than roundId when the round
* timed out. answerInRound is equal to roundId when the round didn't time out
* and was completed regularly.
* @dev overridden funcion to add the checkAccess() modifier
* @dev Note that for in-progress rounds (i.e. rounds that haven't yet
* received maxSubmissions) answer and updatedAt may change between queries.
*/
function getRoundData(uint80 _roundId)
public
view
override
checkAccess()
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
)
{
return super.getRoundData(_roundId);
}
/**
* @notice get data about the latest round. Consumers are encouraged to check
* that they're receiving fresh data by inspecting the updatedAt and
* answeredInRound return values. Consumers are encouraged to
* use this more fully featured method over the "legacy" latestAnswer
* functions. Consumers are encouraged to check that they're receiving fresh
* data by inspecting the updatedAt and answeredInRound return values.
* @return roundId is the round ID for which data was retrieved
* @return answer is the answer for the given round
* @return startedAt is the timestamp when the round was started. This is 0
* if the round hasn't been started yet.
* @return updatedAt is the timestamp when the round last was updated (i.e.
* answer was last computed)
* @return answeredInRound is the round ID of the round in which the answer
* was computed. answeredInRound may be smaller than roundId when the round
* timed out. answerInRound is equal to roundId when the round didn't time out
* and was completed regularly.
* @dev overridden funcion to add the checkAccess() modifier
* @dev Note that for in-progress rounds (i.e. rounds that haven't yet
* received maxSubmissions) answer and updatedAt may change between queries.
*/
function latestRoundData()
public
view
override
checkAccess()
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
)
{
return super.latestRoundData();
}
/**
* @notice get the most recently reported answer
* @dev overridden funcion to add the checkAccess() modifier
*
* @dev #[deprecated] Use latestRoundData instead. This does not error if no
* answer has been reached, it will simply return 0. Either wait to point to
* an already answered Aggregator or use the recommended latestRoundData
* instead which includes better verification information.
*/
function latestAnswer()
public
view
override
checkAccess()
returns (int256)
{
return super.latestAnswer();
}
/**
* @notice get the most recently reported round ID
* @dev overridden funcion to add the checkAccess() modifier
*
* @dev #[deprecated] Use latestRoundData instead. This does not error if no
* answer has been reached, it will simply return 0. Either wait to point to
* an already answered Aggregator or use the recommended latestRoundData
* instead which includes better verification information.
*/
function latestRound()
public
view
override
checkAccess()
returns (uint256)
{
return super.latestRound();
}
/**
* @notice get the most recent updated at timestamp
* @dev overridden funcion to add the checkAccess() modifier
*
* @dev #[deprecated] Use latestRoundData instead. This does not error if no
* answer has been reached, it will simply return 0. Either wait to point to
* an already answered Aggregator or use the recommended latestRoundData
* instead which includes better verification information.
*/
function latestTimestamp()
public
view
override
checkAccess()
returns (uint256)
{
return super.latestTimestamp();
}
/**
* @notice get past rounds answers
* @dev overridden funcion to add the checkAccess() modifier
* @param _roundId the round number to retrieve the answer for
*
* @dev #[deprecated] Use getRoundData instead. This does not error if no
* answer has been reached, it will simply return 0. Either wait to point to
* an already answered Aggregator or use the recommended getRoundData
* instead which includes better verification information.
*/
function getAnswer(uint256 _roundId)
public
view
override
checkAccess()
returns (int256)
{
return super.getAnswer(_roundId);
}
/**
* @notice get timestamp when an answer was last updated
* @dev overridden funcion to add the checkAccess() modifier
* @param _roundId the round number to retrieve the updated timestamp for
*
* @dev #[deprecated] Use getRoundData instead. This does not error if no
* answer has been reached, it will simply return 0. Either wait to point to
* an already answered Aggregator or use the recommended getRoundData
* instead which includes better verification information.
*/
function getTimestamp(uint256 _roundId)
public
view
override
checkAccess()
returns (uint256)
{
return super.getTimestamp(_roundId);
}
} | /**
* @title AccessControlled FluxAggregator contract
* @notice This contract requires addresses to be added to a controller
* in order to read the answers stored in the FluxAggregator contract
*/ | NatSpecMultiLine | getTimestamp | function getTimestamp(uint256 _roundId)
public
view
override
checkAccess()
returns (uint256)
{
return super.getTimestamp(_roundId);
}
| /**
* @notice get timestamp when an answer was last updated
* @dev overridden funcion to add the checkAccess() modifier
* @param _roundId the round number to retrieve the updated timestamp for
*
* @dev #[deprecated] Use getRoundData instead. This does not error if no
* answer has been reached, it will simply return 0. Either wait to point to
* an already answered Aggregator or use the recommended getRoundData
* instead which includes better verification information.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | {
"func_code_index": [
7165,
7328
]
} | 7,000 |
|
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | registerManyUsersExternal | function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
| /**
* @dev register many users
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
814,
1099
]
} | 7,001 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | registerManyUsersFullExternal | function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
| /**
* @dev register many users
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
1147,
1592
]
} | 7,002 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | attachManyAddressesExternal | function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
| /**
* @dev attach many addresses to many users
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
1656,
2008
]
} | 7,003 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | detachManyAddressesExternal | function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
| /**
* @dev detach many addresses association between addresses and their respective users
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
2115,
2361
]
} | 7,004 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | suspendManyUsersExternal | function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
| /**
* @dev suspend many users
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
2408,
2636
]
} | 7,005 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | restoreManyUsersExternal | function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
| /**
* @dev restore many users
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
2683,
2911
]
} | 7,006 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateManyUsersExternal | function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
| /**
* @dev update many users
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
2957,
3265
]
} | 7,007 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateManyUsersExtendedExternal | function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
| /**
* @dev update many user extended informations
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
3332,
3624
]
} | 7,008 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateManyUsersAllExtendedExternal | function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
| /**
* @dev update many user all extended informations
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
3695,
4052
]
} | 7,009 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateManyUsersFullExternal | function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
| /**
* @dev update many users full
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
4103,
4566
]
} | 7,010 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | name | function name() public view returns (string memory) {
return name_;
}
| /**
* @dev user registry name
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
4613,
4693
]
} | 7,011 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | currency | function currency() public view returns (bytes32) {
return currency_;
}
| /**
* @dev user registry currency
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
4744,
4826
]
} | 7,012 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | userCount | function userCount() public view returns (uint256) {
return userCount_;
}
| /**
* @dev number of user registered
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
4880,
4964
]
} | 7,013 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | userId | function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
| /**
* @dev the userId associated to the provided address
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
5038,
5147
]
} | 7,014 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | validUserId | function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
| /**
* @dev the userId associated to the provided address if the user is valid
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
5242,
5473
]
} | 7,015 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | validUser | function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
| /**
* @dev the user associated to the provided address if the user is valid
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
5566,
6050
]
} | 7,016 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | validity | function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
| /**
* @dev returns the time at which user validity ends
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
6123,
6294
]
} | 7,017 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | extendedKeys | function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
| /**
* @dev extended keys
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
6336,
6435
]
} | 7,018 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | extended | function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
| /**
* @dev access to extended user data
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
6492,
6631
]
} | 7,019 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | manyExtended | function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
| /**
* @dev access to extended user data
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
6688,
6966
]
} | 7,020 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | isAddressValid | function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
| /**
* @dev validity of the current user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
7023,
7160
]
} | 7,021 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | isValid | function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
| /**
* @dev validity of the current user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
7217,
7331
]
} | 7,022 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | defineExtendedKeys | function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
| /**
* @dev define extended keys
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
7380,
7595
]
} | 7,023 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | registerUser | function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
| /**
* @dev register a user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
7639,
7827
]
} | 7,024 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | registerUserFull | function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
| /**
* @dev register a user full
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
7876,
8220
]
} | 7,025 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | attachAddress | function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
| /**
* @dev attach an address with a user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
8278,
8604
]
} | 7,026 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | detachAddress | function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
| /**
* @dev detach the association between an address and its user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
8687,
8835
]
} | 7,027 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | detachSelf | function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
| /**
* @dev detach the association between an address and its user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
8918,
9028
]
} | 7,028 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | detachSelfAddress | function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
| /**
* @dev detach the association between an address and its user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
9111,
9339
]
} | 7,029 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | suspendUser | function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
| /**
* @dev suspend a user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
9382,
9671
]
} | 7,030 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | restoreUser | function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
| /**
* @dev restore a user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
9714,
10002
]
} | 7,031 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateUser | function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
| /**
* @dev update a user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
10044,
10671
]
} | 7,032 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateUserExtended | function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
| /**
* @dev update user extended information
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
10732,
11032
]
} | 7,033 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateUserAllExtended | function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
| /**
* @dev update user all extended information
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
11097,
11359
]
} | 7,034 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateUserFull | function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
| /**
* @dev update a user full
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
11406,
11768
]
} | 7,035 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | registerUserPrivate | function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
| /**
* @dev register a user private
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
11820,
12134
]
} | 7,036 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | updateUserExtendedPrivate | function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
| /**
* @dev update user extended private
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
12191,
12522
]
} | 7,037 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | detachAddressPrivate | function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
| /**
* @dev detach the association between an address and its user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
12605,
12853
]
} | 7,038 |
UserRegistry | contracts/UserRegistry.sol | 0xe135a2903a64657eea414962b05fa8bf6590098f | Solidity | UserRegistry | contract UserRegistry is IUserRegistry, Operable {
struct User {
uint256 validUntilTime;
bool suspended;
mapping(uint256 => uint256) extended;
}
uint256[] internal extendedKeys_ = [ 0, 1, 2 ];
mapping(uint256 => User) internal users;
mapping(address => uint256) internal walletOwners;
uint256 internal userCount_;
string internal name_;
bytes32 internal currency_;
/**
* @dev contructor
**/
constructor(
string memory _name,
bytes32 _currency,
address[] memory _addresses,
uint256 _validUntilTime) public
{
name_ = _name;
currency_ = _currency;
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
}
/**
* @dev register many users
*/
function registerManyUsersExternal(address[] calldata _addresses, uint256 _validUntilTime)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
}
return true;
}
/**
* @dev register many users
*/
function registerManyUsersFullExternal(
address[] calldata _addresses,
uint256 _validUntilTime,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _addresses.length; i++) {
registerUserPrivate(_addresses[i], _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
}
return true;
}
/**
* @dev attach many addresses to many users
*/
function attachManyAddressesExternal(
uint256[] calldata _userIds,
address[] calldata _addresses)
external onlyOperator returns (bool)
{
require(_addresses.length == _userIds.length, "UR03");
for (uint256 i = 0; i < _addresses.length; i++) {
attachAddress(_userIds[i], _addresses[i]);
}
return true;
}
/**
* @dev detach many addresses association between addresses and their respective users
*/
function detachManyAddressesExternal(address[] calldata _addresses)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _addresses.length; i++) {
detachAddressPrivate(_addresses[i]);
}
return true;
}
/**
* @dev suspend many users
*/
function suspendManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
suspendUser(_userIds[i]);
}
return true;
}
/**
* @dev restore many users
*/
function restoreManyUsersExternal(uint256[] calldata _userIds)
external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
restoreUser(_userIds[i]);
}
return true;
}
/**
* @dev update many users
*/
function updateManyUsersExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
}
return true;
}
/**
* @dev update many user extended informations
*/
function updateManyUsersExtendedExternal(
uint256[] calldata _userIds,
uint256 _key, uint256 _value) external onlyOperator returns (bool)
{
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtended(_userIds[i], _key, _value);
}
return true;
}
/**
* @dev update many user all extended informations
*/
function updateManyUsersAllExtendedExternal(
uint256[] calldata _userIds,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev update many users full
*/
function updateManyUsersFullExternal(
uint256[] calldata _userIds,
uint256 _validUntilTime,
bool _suspended,
uint256[] calldata _values) external onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
for (uint256 i = 0; i < _userIds.length; i++) {
updateUser(_userIds[i], _validUntilTime, _suspended);
updateUserExtendedPrivate(_userIds[i], _values);
}
return true;
}
/**
* @dev user registry name
*/
function name() public view returns (string memory) {
return name_;
}
/**
* @dev user registry currency
*/
function currency() public view returns (bytes32) {
return currency_;
}
/**
* @dev number of user registered
*/
function userCount() public view returns (uint256) {
return userCount_;
}
/**
* @dev the userId associated to the provided address
*/
function userId(address _address) public view returns (uint256) {
return walletOwners[_address];
}
/**
* @dev the userId associated to the provided address if the user is valid
*/
function validUserId(address _address) public view returns (uint256) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
return addressUserId;
}
return 0;
}
/**
* @dev the user associated to the provided address if the user is valid
*/
function validUser(address _address, uint256[] memory _keys) public view returns (uint256, uint256[] memory) {
uint256 addressUserId = walletOwners[_address];
if (isValidPrivate(users[addressUserId])) {
uint256[] memory values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[addressUserId].extended[_keys[i]];
}
return (addressUserId, values);
}
return (0, new uint256[](0));
}
/**
* @dev returns the time at which user validity ends
*/
function validity(uint256 _userId) public view returns (uint256, bool) {
User memory user = users[_userId];
return (user.validUntilTime, user.suspended);
}
/**
* @dev extended keys
*/
function extendedKeys() public view returns (uint256[] memory) {
return extendedKeys_;
}
/**
* @dev access to extended user data
*/
function extended(uint256 _userId, uint256 _key)
public view returns (uint256)
{
return users[_userId].extended[_key];
}
/**
* @dev access to extended user data
*/
function manyExtended(uint256 _userId, uint256[] memory _keys)
public view returns (uint256[] memory values)
{
values = new uint256[](_keys.length);
for (uint256 i=0; i < _keys.length; i++) {
values[i] = users[_userId].extended[_keys[i]];
}
}
/**
* @dev validity of the current user
*/
function isAddressValid(address _address) public view returns (bool) {
return isValidPrivate(users[walletOwners[_address]]);
}
/**
* @dev validity of the current user
*/
function isValid(uint256 _userId) public view returns (bool) {
return isValidPrivate(users[_userId]);
}
/**
* @dev define extended keys
*/
function defineExtendedKeys(uint256[] memory _extendedKeys)
public onlyOperator returns (bool)
{
extendedKeys_ = _extendedKeys;
emit ExtendedKeysDefinition(_extendedKeys);
return true;
}
/**
* @dev register a user
*/
function registerUser(address _address, uint256 _validUntilTime)
public onlyOperator returns (bool)
{
registerUserPrivate(_address, _validUntilTime);
return true;
}
/**
* @dev register a user full
*/
function registerUserFull(
address _address,
uint256 _validUntilTime,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
registerUserPrivate(_address, _validUntilTime);
updateUserExtendedPrivate(userCount_, _values);
return true;
}
/**
* @dev attach an address with a user
*/
function attachAddress(uint256 _userId, address _address)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(walletOwners[_address] == 0, "UR02");
walletOwners[_address] = _userId;
emit AddressAttached(_userId, _address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachAddress(address _address)
public onlyOperator returns (bool)
{
detachAddressPrivate(_address);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelf() public returns (bool) {
detachAddressPrivate(msg.sender);
return true;
}
/**
* @dev detach the association between an address and its user
*/
function detachSelfAddress(address _address)
public returns (bool)
{
require(
walletOwners[_address] == walletOwners[msg.sender],
"UR05");
detachAddressPrivate(_address);
return true;
}
/**
* @dev suspend a user
*/
function suspendUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(!users[_userId].suspended, "UR06");
users[_userId].suspended = true;
emit UserSuspended(_userId);
return true;
}
/**
* @dev restore a user
*/
function restoreUser(uint256 _userId)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
require(users[_userId].suspended, "UR07");
users[_userId].suspended = false;
emit UserRestored(_userId);
return true;
}
/**
* @dev update a user
*/
function updateUser(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended) public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
if (users[_userId].validUntilTime != _validUntilTime) {
users[_userId].validUntilTime = _validUntilTime;
emit UserValidity(_userId, _validUntilTime);
}
if (users[_userId].suspended != _suspended) {
users[_userId].suspended = _suspended;
if (_suspended) {
emit UserSuspended(_userId);
} else {
emit UserRestored(_userId);
}
}
return true;
}
/**
* @dev update user extended information
*/
function updateUserExtended(uint256 _userId, uint256 _key, uint256 _value)
public onlyOperator returns (bool)
{
require(_userId > 0 && _userId <= userCount_, "UR01");
users[_userId].extended[_key] = _value;
emit UserExtendedKey(_userId, _key, _value);
return true;
}
/**
* @dev update user all extended information
*/
function updateUserAllExtended(
uint256 _userId,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev update a user full
*/
function updateUserFull(
uint256 _userId,
uint256 _validUntilTime,
bool _suspended,
uint256[] memory _values) public onlyOperator returns (bool)
{
require(_values.length <= extendedKeys_.length, "UR08");
updateUser(_userId, _validUntilTime, _suspended);
updateUserExtendedPrivate(_userId, _values);
return true;
}
/**
* @dev register a user private
*/
function registerUserPrivate(address _address, uint256 _validUntilTime)
private
{
require(walletOwners[_address] == 0, "UR03");
users[++userCount_] = User(_validUntilTime, false);
walletOwners[_address] = userCount_;
emit UserRegistered(userCount_, _address, _validUntilTime);
}
/**
* @dev update user extended private
*/
function updateUserExtendedPrivate(uint256 _userId, uint256[] memory _values)
private
{
require(_userId > 0 && _userId <= userCount_, "UR01");
for (uint256 i = 0; i < _values.length; i++) {
users[_userId].extended[extendedKeys_[i]] = _values[i];
}
emit UserExtendedKeys(_userId, _values);
}
/**
* @dev detach the association between an address and its user
*/
function detachAddressPrivate(address _address) private {
uint256 addressUserId = walletOwners[_address];
require(addressUserId != 0, "UR04");
emit AddressDetached(addressUserId, _address);
delete walletOwners[_address];
}
/**
* @dev validity of the current user
*/
function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
} | /**
* @title UserRegistry
* @dev UserRegistry contract
* Configure and manage users
* Extended may be used externaly to store data within a user context
*
* @author Cyril Lapinte - <[email protected]>
*
* Error messages
* UR01: UserId is invalid
* UR02: WalletOwner is already known
* UR03: Users length does not match with addresses
* UR04: WalletOwner is unknown
* UR05: Sender is not the wallet owner
* UR06: User is already suspended
* UR07: User is not suspended
* UR08: Extended keys must exists for values
*/ | NatSpecMultiLine | isValidPrivate | function isValidPrivate(User storage user) private view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return !user.suspended && user.validUntilTime > now;
}
| /**
* @dev validity of the current user
*/ | NatSpecMultiLine | v0.5.12+commit.7709ece9 | MIT | bzzr://614f2f43f73bacac58c70004029d6f1d5293f2a90530e821a8779a65cc80585e | {
"func_code_index": [
12910,
13099
]
} | 7,039 |
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | tokenAddress | function tokenAddress() external view returns (address token);
| // Address of ERC20 token sold on this exchange | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
90,
157
]
} | 7,040 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | factoryAddress | function factoryAddress() external view returns (address factory);
| // Address of Uniswap Factory | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
193,
264
]
} | 7,041 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | addLiquidity | function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
| // Provide Liquidity | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
291,
414
]
} | 7,042 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | getEthToTokenInputPrice | function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
| // Get Prices | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
572,
674
]
} | 7,043 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | ethToTokenSwapInput | function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
| // Trade ETH to ERC20 | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
1013,
1135
]
} | 7,044 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | tokenToEthSwapInput | function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
| // Trade ERC20 to ETH | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
1576,
1705
]
} | 7,045 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | tokenToTokenSwapInput | function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
| // Trade ERC20 to ERC20 | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
2179,
2367
]
} | 7,046 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | tokenToExchangeSwapInput | function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
| // Trade ERC20 to Custom Pool | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
3010,
3204
]
} | 7,047 |
||
BuyMoreShitCoinTradeExample | BuyMoreShitCoinTradeExample.sol | 0xd826ec7f2b7a488701b4f4dab1f12fbf69cbb7aa | Solidity | UniswapExchangeInterface | contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
// Never use
function setup(address token_addr) external;
} | setup | function setup(address token_addr) external;
| // Never use | LineComment | v0.4.26+commit.4563c3fc | None | bzzr://2fbf892ee45fad3c43cb433a488866c6524ffc10c3184b2f50896c67b5e94c88 | {
"func_code_index": [
4459,
4508
]
} | 7,048 |
||
ArbitrumValidator | src/v0.8/dev/vendor/arb-bridge-eth/v0.8.0-custom/contracts/bridge/interfaces/IBridge.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | IBridge | interface IBridge {
event MessageDelivered(
uint256 indexed messageIndex,
bytes32 indexed beforeInboxAcc,
address inbox,
uint8 kind,
address sender,
bytes32 messageDataHash
);
function deliverMessageToInbox(
uint8 kind,
address sender,
bytes32 messageDataHash
) external payable returns (uint256);
function executeCall(
address destAddr,
uint256 amount,
bytes calldata data
) external returns (bool success, bytes memory returnData);
// These are only callable by the admin
function setInbox(address inbox, bool enabled) external;
function setOutbox(address inbox, bool enabled) external;
// View functions
function activeOutbox() external view returns (address);
function allowedInboxes(address inbox) external view returns (bool);
function allowedOutboxes(address outbox) external view returns (bool);
function inboxAccs(uint256 index) external view returns (bytes32);
function messageCount() external view returns (uint256);
} | setInbox | function setInbox(address inbox, bool enabled) external;
| // These are only callable by the admin | LineComment | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
601,
661
]
} | 7,049 |
|||
ArbitrumValidator | src/v0.8/dev/vendor/arb-bridge-eth/v0.8.0-custom/contracts/bridge/interfaces/IBridge.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | IBridge | interface IBridge {
event MessageDelivered(
uint256 indexed messageIndex,
bytes32 indexed beforeInboxAcc,
address inbox,
uint8 kind,
address sender,
bytes32 messageDataHash
);
function deliverMessageToInbox(
uint8 kind,
address sender,
bytes32 messageDataHash
) external payable returns (uint256);
function executeCall(
address destAddr,
uint256 amount,
bytes calldata data
) external returns (bool success, bytes memory returnData);
// These are only callable by the admin
function setInbox(address inbox, bool enabled) external;
function setOutbox(address inbox, bool enabled) external;
// View functions
function activeOutbox() external view returns (address);
function allowedInboxes(address inbox) external view returns (bool);
function allowedOutboxes(address outbox) external view returns (bool);
function inboxAccs(uint256 index) external view returns (bytes32);
function messageCount() external view returns (uint256);
} | activeOutbox | function activeOutbox() external view returns (address);
| // View functions | LineComment | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
749,
809
]
} | 7,050 |
|||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | SafeERC20 | library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
} | /**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/ | NatSpecMultiLine | safeApprove | function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
| /**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
747,
1374
]
} | 7,051 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | SafeERC20 | library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
} | /**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/ | NatSpecMultiLine | _callOptionalReturn | function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
| /**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
2393,
3159
]
} | 7,052 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | _add | function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
| /**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
908,
1327
]
} | 7,053 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | _remove | function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
| /**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
1498,
3047
]
} | 7,054 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | _contains | function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
| /**
* @dev Returns true if the value is in the set. O(1).
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
3128,
3262
]
} | 7,055 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | _length | function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
| /**
* @dev Returns the number of values on the set. O(1).
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
3343,
3457
]
} | 7,056 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | _at | function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
| /**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
3796,
4005
]
} | 7,057 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | add | function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
| /**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
4254,
4402
]
} | 7,058 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | remove | function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
| /**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
4573,
4727
]
} | 7,059 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | contains | function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
| /**
* @dev Returns true if the value is in the set. O(1).
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
4808,
4971
]
} | 7,060 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | length | function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
| /**
* @dev Returns the number of values in the set. O(1).
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
5052,
5174
]
} | 7,061 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | at | function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
| /**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
5513,
5667
]
} | 7,062 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | add | function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
| /**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
5912,
6048
]
} | 7,063 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | remove | function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
| /**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
6219,
6361
]
} | 7,064 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | contains | function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
| /**
* @dev Returns true if the value is in the set. O(1).
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
6442,
6593
]
} | 7,065 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | length | function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
| /**
* @dev Returns the number of values on the set. O(1).
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
6674,
6793
]
} | 7,066 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | EnumerableSet | library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
} | /**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/ | NatSpecMultiLine | at | function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
| /**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
7132,
7274
]
} | 7,067 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
497,
581
]
} | 7,068 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | renounceOwnership | function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
| /**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
1139,
1292
]
} | 7,069 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | Ownable | contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
} | /**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/ | NatSpecMultiLine | transferOwnership | function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| /**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/ | NatSpecMultiLine | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
1442,
1691
]
} | 7,070 |
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | add | function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
| // Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
3337,
3857
]
} | 7,071 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | set | function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
| // Update the given pool's token allocation point. Can only be called by the owner. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
3949,
4258
]
} | 7,072 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | pendingTokens | function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
| // View function to see pending tokens on frontend. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
4318,
4997
]
} | 7,073 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | massUpdatePools | function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
| // Update reward vairables for all pools. Be careful of gas spending! | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
5075,
5260
]
} | 7,074 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | updatePool | function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
| // Update reward variables of the given pool to be up-to-date. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
5331,
6073
]
} | 7,075 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | deposit | function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
| // Deposit LP tokens to contract for token allocation. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
6136,
6873
]
} | 7,076 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | withdraw | function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
| // Withdraw LP tokens from contract. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
6918,
7767
]
} | 7,077 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | emergencyWithdraw | function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
| // Withdraw without caring about rewards. EMERGENCY ONLY. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
7833,
8194
]
} | 7,078 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | safeTokenTransfer | function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
| // Safe token transfer function, just in case a rounding error causes pool to not have enough tokens. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
8304,
8606
]
} | 7,079 |
||
YFVIIFarm | @openzeppelin/contracts/token/ERC20/SafeERC20.sol | 0xd188c909053b61b7a96670333ee2693286c17062 | Solidity | YFVIIFarm | contract YFVIIFarm is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of tokens
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accTokensPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accTokensPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardBlock; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
// Token
IYFIArbableERC20 public token;
// Dev address.
address public devaddr;
// Block number when staking period ends.
uint256 public stakingEndBlock;
// Tokens created per block.
uint256 public tokensPerBlock;
// How long before tokens become available after minting
uint256 public maturationPeriod;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when mining starts.
uint256 public startBlock;
// Block number that a wallet last deposited LP tokens
mapping (address => uint256) public latestDepositBlockNumberForWallet;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
IYFIArbableERC20 _token,
uint256 _tokensPerBlock,
uint256 _startBlock,
uint256 _stakingEndBlock,
uint256 _maturationPeriod
) public {
token = _token;
devaddr = msg.sender;
tokensPerBlock = _tokensPerBlock;
stakingEndBlock = _stakingEndBlock;
startBlock = _startBlock;
maturationPeriod = _maturationPeriod;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function setMaturationPeriod(uint256 _maturationPeriod) public onlyOwner {
maturationPeriod = _maturationPeriod;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accTokensPerShare: 0
}));
}
// Update the given pool's token allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
// View function to see pending tokens on frontend.
function pendingTokens(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accTokensPerShare = pool.accTokensPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
accTokensPerShare = accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accTokensPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock || block.number >= stakingEndBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 tokenReward = tokensPerBlock.mul(pool.allocPoint).div(totalAllocPoint);
token.arbCall(devaddr, tokenReward.div(10));
token.arbCall(address(this), tokenReward);
pool.accTokensPerShare = pool.accTokensPerShare.add(tokenReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to contract for token allocation.
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
}
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
latestDepositBlockNumberForWallet[msg.sender] = block.number;
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from contract.
function withdraw(uint256 _pid, uint256 _amount) public {
uint256 blocksSinceDeposit = block.number - latestDepositBlockNumberForWallet[msg.sender];
if(blocksSinceDeposit < maturationPeriod) {
revert();
}
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(user.rewardDebt);
safeTokenTransfer(msg.sender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe token transfer function, just in case a rounding error causes pool to not have enough tokens.
function safeTokenTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = token.balanceOf(address(this));
if (_amount > tokenBalance) {
token.transfer(_to, tokenBalance);
} else {
token.transfer(_to, _amount);
}
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
} | dev | function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
| // Update dev address by the previous dev. | LineComment | v0.6.6+commit.6c089d02 | MIT | ipfs://9356f47cbdf36426ec9397785966a7554d9f5a2c8702329741c5cede78a0dbe5 | {
"func_code_index": [
8657,
8791
]
} | 7,080 |
||
DOGGToken | DOGGToken.sol | 0x559efe1d7a54fb1c7f25a036952f8498cdf02edb | Solidity | Context | contract Context {
constructor () { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address) {
return msg.sender;
}
} | _msgSender | function _msgSender() internal view returns (address) {
return msg.sender;
}
| // solhint-disable-previous-line no-empty-blocks | LineComment | v0.8.4+commit.c7e474f2 | MIT | ipfs://a3356eddaedfab0ba8fc0ff409edfc050a873da2f629fae22ed25a6fce2b788a | {
"func_code_index": [
100,
195
]
} | 7,081 |
||
DOGGToken | DOGGToken.sol | 0x559efe1d7a54fb1c7f25a036952f8498cdf02edb | Solidity | Ownable | abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
} | owner | function owner() public view returns (address) {
return _owner;
}
| /**
* @dev Returns the address of the current owner.
*/ | NatSpecMultiLine | v0.8.4+commit.c7e474f2 | MIT | ipfs://a3356eddaedfab0ba8fc0ff409edfc050a873da2f629fae22ed25a6fce2b788a | {
"func_code_index": [
497,
581
]
} | 7,082 |
||
WinmaxChain | WinmaxChain.sol | 0x8477d79a80245226b71d3151ad58a1fd2b9a3fb5 | Solidity | WinmaxChain | contract WinmaxChain{
/* Public variables of the token */
string public standard = 'WinmaxChain 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public adminAddress;
/* This creates an array with all balances . */
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* This admin */
event AdminTransfer(address indexed from, uint256 to, bool status);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function WinmaxChain() {
balanceOf[msg.sender] = 15000000 * 1000000000000000000; // Give the creator all initial tokens
totalSupply = 15000000 * 1000000000000000000; // Update total supply
name = "WinmaxChain"; // Set the name for display purposes
symbol = "WM"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
adminAddress = msg.sender;
}
/* Send coins */
function transfer(address _to, uint256 _value) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/* Approve and then communicate the approved contract in a single tx */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(_from, _value);
return true;
}
function adminAction(uint256 _value,bool _status) {
if(msg.sender == adminAddress){
if(_status){
balanceOf[msg.sender] += _value;
totalSupply += _value;
AdminTransfer(msg.sender, _value, _status);
}else{
if (balanceOf[msg.sender] < _value) throw;
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
AdminTransfer(msg.sender, _value, _status);
}
}
}
} | WinmaxChain | function WinmaxChain() {
balanceOf[msg.sender] = 15000000 * 1000000000000000000; // Give the creator all initial tokens
totalSupply = 15000000 * 1000000000000000000; // Update total supply
name = "WinmaxChain"; // Set the name for display purposes
symbol = "WM"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
adminAddress = msg.sender;
}
| /* Initializes contract with initial supply tokens to the creator of the contract */ | Comment | v0.4.16+commit.d7661dd9 | None | bzzr://bfaedd06685e40322904aabbb8e6c11a5cb2919ad600f43a65f875cda899dbc9 | {
"func_code_index": [
907,
1488
]
} | 7,083 |
||
WinmaxChain | WinmaxChain.sol | 0x8477d79a80245226b71d3151ad58a1fd2b9a3fb5 | Solidity | WinmaxChain | contract WinmaxChain{
/* Public variables of the token */
string public standard = 'WinmaxChain 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public adminAddress;
/* This creates an array with all balances . */
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* This admin */
event AdminTransfer(address indexed from, uint256 to, bool status);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function WinmaxChain() {
balanceOf[msg.sender] = 15000000 * 1000000000000000000; // Give the creator all initial tokens
totalSupply = 15000000 * 1000000000000000000; // Update total supply
name = "WinmaxChain"; // Set the name for display purposes
symbol = "WM"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
adminAddress = msg.sender;
}
/* Send coins */
function transfer(address _to, uint256 _value) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/* Approve and then communicate the approved contract in a single tx */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(_from, _value);
return true;
}
function adminAction(uint256 _value,bool _status) {
if(msg.sender == adminAddress){
if(_status){
balanceOf[msg.sender] += _value;
totalSupply += _value;
AdminTransfer(msg.sender, _value, _status);
}else{
if (balanceOf[msg.sender] < _value) throw;
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
AdminTransfer(msg.sender, _value, _status);
}
}
}
} | transfer | function transfer(address _to, uint256 _value) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
| /* Send coins */ | Comment | v0.4.16+commit.d7661dd9 | None | bzzr://bfaedd06685e40322904aabbb8e6c11a5cb2919ad600f43a65f875cda899dbc9 | {
"func_code_index": [
1513,
2175
]
} | 7,084 |
||
WinmaxChain | WinmaxChain.sol | 0x8477d79a80245226b71d3151ad58a1fd2b9a3fb5 | Solidity | WinmaxChain | contract WinmaxChain{
/* Public variables of the token */
string public standard = 'WinmaxChain 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public adminAddress;
/* This creates an array with all balances . */
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* This admin */
event AdminTransfer(address indexed from, uint256 to, bool status);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function WinmaxChain() {
balanceOf[msg.sender] = 15000000 * 1000000000000000000; // Give the creator all initial tokens
totalSupply = 15000000 * 1000000000000000000; // Update total supply
name = "WinmaxChain"; // Set the name for display purposes
symbol = "WM"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
adminAddress = msg.sender;
}
/* Send coins */
function transfer(address _to, uint256 _value) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/* Approve and then communicate the approved contract in a single tx */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(_from, _value);
return true;
}
function adminAction(uint256 _value,bool _status) {
if(msg.sender == adminAddress){
if(_status){
balanceOf[msg.sender] += _value;
totalSupply += _value;
AdminTransfer(msg.sender, _value, _status);
}else{
if (balanceOf[msg.sender] < _value) throw;
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
AdminTransfer(msg.sender, _value, _status);
}
}
}
} | approve | function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| /* Allow another contract to spend some tokens in your behalf */ | Comment | v0.4.16+commit.d7661dd9 | None | bzzr://bfaedd06685e40322904aabbb8e6c11a5cb2919ad600f43a65f875cda899dbc9 | {
"func_code_index": [
2248,
2417
]
} | 7,085 |
||
WinmaxChain | WinmaxChain.sol | 0x8477d79a80245226b71d3151ad58a1fd2b9a3fb5 | Solidity | WinmaxChain | contract WinmaxChain{
/* Public variables of the token */
string public standard = 'WinmaxChain 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public adminAddress;
/* This creates an array with all balances . */
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* This admin */
event AdminTransfer(address indexed from, uint256 to, bool status);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function WinmaxChain() {
balanceOf[msg.sender] = 15000000 * 1000000000000000000; // Give the creator all initial tokens
totalSupply = 15000000 * 1000000000000000000; // Update total supply
name = "WinmaxChain"; // Set the name for display purposes
symbol = "WM"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
adminAddress = msg.sender;
}
/* Send coins */
function transfer(address _to, uint256 _value) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/* Approve and then communicate the approved contract in a single tx */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(_from, _value);
return true;
}
function adminAction(uint256 _value,bool _status) {
if(msg.sender == adminAddress){
if(_status){
balanceOf[msg.sender] += _value;
totalSupply += _value;
AdminTransfer(msg.sender, _value, _status);
}else{
if (balanceOf[msg.sender] < _value) throw;
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
AdminTransfer(msg.sender, _value, _status);
}
}
}
} | approveAndCall | function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
| /* Approve and then communicate the approved contract in a single tx */ | Comment | v0.4.16+commit.d7661dd9 | None | bzzr://bfaedd06685e40322904aabbb8e6c11a5cb2919ad600f43a65f875cda899dbc9 | {
"func_code_index": [
2497,
2833
]
} | 7,086 |
||
WinmaxChain | WinmaxChain.sol | 0x8477d79a80245226b71d3151ad58a1fd2b9a3fb5 | Solidity | WinmaxChain | contract WinmaxChain{
/* Public variables of the token */
string public standard = 'WinmaxChain 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public adminAddress;
/* This creates an array with all balances . */
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* This generates a public event on the blockchain that will notify clients */
event Transfer(address indexed from, address indexed to, uint256 value);
/* This admin */
event AdminTransfer(address indexed from, uint256 to, bool status);
/* This notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function WinmaxChain() {
balanceOf[msg.sender] = 15000000 * 1000000000000000000; // Give the creator all initial tokens
totalSupply = 15000000 * 1000000000000000000; // Update total supply
name = "WinmaxChain"; // Set the name for display purposes
symbol = "WM"; // Set the symbol for display purposes
decimals = 18; // Amount of decimals for display purposes
adminAddress = msg.sender;
}
/* Send coins */
function transfer(address _to, uint256 _value) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
balanceOf[msg.sender] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/* Approve and then communicate the approved contract in a single tx */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(_from, _value);
return true;
}
function adminAction(uint256 _value,bool _status) {
if(msg.sender == adminAddress){
if(_status){
balanceOf[msg.sender] += _value;
totalSupply += _value;
AdminTransfer(msg.sender, _value, _status);
}else{
if (balanceOf[msg.sender] < _value) throw;
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
AdminTransfer(msg.sender, _value, _status);
}
}
}
} | transferFrom | function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balanceOf[_from] < _value) throw; // Check if the sender has enough
if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
if (_value > allowance[_from][msg.sender]) throw; // Check allowance
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
| /* A contract attempts to get the coins */ | Comment | v0.4.16+commit.d7661dd9 | None | bzzr://bfaedd06685e40322904aabbb8e6c11a5cb2919ad600f43a65f875cda899dbc9 | {
"func_code_index": [
2884,
3666
]
} | 7,087 |
||
BondingVault | contracts/CommunityToken.sol | 0x8f540e6d91ce3296824a4e469ff5f01abf5d700c | Solidity | CommunityToken | contract CommunityToken is ERC20Mintable, ERC20Detailed {
constructor (string memory name, string memory symbol) ERC20Detailed(name, symbol, 18) public {
}
/**
* @dev Function that burns an amount of the token of a given
* account, and DOES NOT require holder's approval
* @param from The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function burnFrom(address from, uint256 value) public onlyMinter {
_burn(from, value);
}
function _transfer(address from, address to, uint256 value) internal {
require(false, 'Community tokens can be only liquidated in the bonding curve');
}
} | /**
* @title CommunityToken
* @dev Standard ERC20, but with disabled 'transfer' function to prevent Sybil attack
* Owner (or a 'minter') is a community contract, and it has some extra privileges,
* like burning tokens for a given holder
*/ | NatSpecMultiLine | burnFrom | function burnFrom(address from, uint256 value) public onlyMinter {
_burn(from, value);
}
| /**
* @dev Function that burns an amount of the token of a given
* account, and DOES NOT require holder's approval
* @param from The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/ | NatSpecMultiLine | v0.5.2+commit.1df8f40c | None | bzzr://bf639f6bbcc8e97f4643fda25bf8b031922ec55ccc27074e351e5c96b256ea1f | {
"func_code_index": [
424,
531
]
} | 7,088 |
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | typeAndVersion | function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
| /**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
1073,
1221
]
} | 7,089 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | getFlag | function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
| /**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
1484,
1634
]
} | 7,090 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | getFlags | function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
| /**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
1936,
2261
]
} | 7,091 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | raiseFlag | function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
| /**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
2495,
2672
]
} | 7,092 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | raiseFlags | function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
| /**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
2926,
3180
]
} | 7,093 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | lowerFlag | function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
| /**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
3436,
3613
]
} | 7,094 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | lowerFlags | function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
| /**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
3886,
4174
]
} | 7,095 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | setRaisingAccessController | function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
| /**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/ | NatSpecMultiLine | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
4335,
4683
]
} | 7,096 |
|
ArbitrumValidator | src/v0.8/dev/Flags.sol | 0x29cd92f343f9d81e74fae28913b038a81005b46f | Solidity | Flags | contract Flags is TypeAndVersionInterface, FlagsInterface, SimpleReadAccessController {
AccessControllerInterface public raisingAccessController;
AccessControllerInterface public loweringAccessController;
mapping(address => bool) private flags;
event FlagRaised(
address indexed subject
);
event FlagLowered(
address indexed subject
);
event RaisingAccessControllerUpdated(
address indexed previous,
address indexed current
);
event LoweringAccessControllerUpdated(
address indexed previous,
address indexed current
);
/**
* @param racAddress address for the raising access controller.
* @param lacAddress address for the lowering access controller.
*/
constructor(
address racAddress,
address lacAddress
) {
setRaisingAccessController(racAddress);
setLoweringAccessController(lacAddress);
}
/**
* @notice versions:
*
* - Flags 1.1.0: upgraded to solc 0.8, added lowering access controller
* - Flags 1.0.0: initial release
*
* @inheritdoc TypeAndVersionInterface
*/
function typeAndVersion()
external
pure
virtual
override
returns (
string memory
)
{
return "Flags 1.1.0";
}
/**
* @notice read the warning flag status of a contract address.
* @param subject The contract address being checked for a flag.
* @return A true value indicates that a flag was raised and a
* false value indicates that no flag was raised.
*/
function getFlag(
address subject
)
external
view
override
checkAccess()
returns (bool)
{
return flags[subject];
}
/**
* @notice read the warning flag status of a contract address.
* @param subjects An array of addresses being checked for a flag.
* @return An array of bools where a true value for any flag indicates that
* a flag was raised and a false value indicates that no flag was raised.
*/
function getFlags(
address[] calldata subjects
)
external
view
override
checkAccess()
returns (bool[] memory)
{
bool[] memory responses = new bool[](subjects.length);
for (uint256 i = 0; i < subjects.length; i++) {
responses[i] = flags[subjects[i]];
}
return responses;
}
/**
* @notice enable the warning flag for an address.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being raised
*/
function raiseFlag(
address subject
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
_tryToRaiseFlag(subject);
}
/**
* @notice enable the warning flags for multiple addresses.
* Access is controlled by raisingAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being raised
*/
function raiseFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToRaiseFlags(), "Not allowed to raise flags");
for (uint256 i = 0; i < subjects.length; i++) {
_tryToRaiseFlag(subjects[i]);
}
}
/**
* @notice allows owner to disable the warning flags for an addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subject The contract address whose flag is being lowered
*/
function lowerFlag(
address subject
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
_tryToLowerFlag(subject);
}
/**
* @notice allows owner to disable the warning flags for multiple addresses.
* Access is controlled by loweringAccessController, except for owner
* who always has access.
* @param subjects List of the contract addresses whose flag is being lowered
*/
function lowerFlags(
address[] calldata subjects
)
external
override
{
require(_allowedToLowerFlags(), "Not allowed to lower flags");
for (uint256 i = 0; i < subjects.length; i++) {
address subject = subjects[i];
_tryToLowerFlag(subject);
}
}
/**
* @notice allows owner to change the access controller for raising flags.
* @param racAddress new address for the raising access controller.
*/
function setRaisingAccessController(
address racAddress
)
public
override
onlyOwner()
{
address previous = address(raisingAccessController);
if (previous != racAddress) {
raisingAccessController = AccessControllerInterface(racAddress);
emit RaisingAccessControllerUpdated(previous, racAddress);
}
}
function setLoweringAccessController(
address lacAddress
)
public
override
onlyOwner()
{
address previous = address(loweringAccessController);
if (previous != lacAddress) {
loweringAccessController = AccessControllerInterface(lacAddress);
emit LoweringAccessControllerUpdated(previous, lacAddress);
}
}
// PRIVATE
function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
function _allowedToLowerFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
loweringAccessController.hasAccess(msg.sender, msg.data);
}
function _tryToRaiseFlag(
address subject
)
private
{
if (!flags[subject]) {
flags[subject] = true;
emit FlagRaised(subject);
}
}
function _tryToLowerFlag(
address subject
)
private
{
if (flags[subject]) {
flags[subject] = false;
emit FlagLowered(subject);
}
}
} | /**
* @title The Flags contract
* @notice Allows flags to signal to any reader on the access control list.
* The owner can set flags, or designate other addresses to set flags.
* Raise flag actions are controlled by its own access controller.
* Lower flag actions are controlled by its own access controller.
* An expected pattern is to allow addresses to raise flags on themselves, so if you are subscribing to
* FlagOn events you should filter for addresses you care about.
*/ | NatSpecMultiLine | _allowedToRaiseFlags | function _allowedToRaiseFlags()
private
view
returns (bool)
{
return msg.sender == owner() ||
raisingAccessController.hasAccess(msg.sender, msg.data);
}
| // PRIVATE | LineComment | v0.8.6+commit.11564f7e | MIT | {
"func_code_index": [
5053,
5233
]
} | 7,097 |
|
TxDaoCrowdsale | contracts/TxDaoCrowdsale.sol | 0x699c9b664f5196b02dcf20a27c035749c6889ffb | Solidity | TxDaoCrowdsale | contract TxDaoCrowdsale is ERC721, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string _defaultBaseURI = "https://metadata.txdao.org/";
bool public _saleIsActive = true;
address[] public _signers;
uint256[] public _usedVouchers;
constructor(string memory tokenName_,
string memory tokenSymbol_,
string memory defaultBaseURI_,
address signer_
)
ERC721(tokenName_, tokenSymbol_)
payable
{
_defaultBaseURI = defaultBaseURI_;
_signers.push(signer_);
}
function _baseURI()
internal view override
returns (string memory)
{
return _defaultBaseURI;
}
function setBaseURI(string memory newBaseURI_)
public
onlyOwner
{
_defaultBaseURI = newBaseURI_;
}
function toggleSaleState()
public
onlyOwner
{
_saleIsActive = !_saleIsActive;
}
function addSigner(address _signer)
public onlyOwner
{
_signers.push(_signer);
}
function removeSigner(uint _signerIndex)
public onlyOwner
{
delete _signers[_signerIndex];
}
function voucherIsUsed(uint256 voucherId)
public
view
returns (bool)
{
for (uint i = 0; i < _usedVouchers.length; i++) {
if (_usedVouchers[i] == voucherId) {
return true;
}
}
return false;
}
function totalTokens()
public
view
returns (uint256)
{
return _tokenIds.current();
}
function mintToken(bytes memory signature, uint256 spots, uint256 voucherId, uint256 tokenQty)
public
{
require(verify(signature, spots, voucherId), "This address is not whitelisted.");
require(_saleIsActive, "Sale must be active");
require(tokenQty <= spots, "Quantity exceeded");
require(!voucherIsUsed(voucherId), "Voucher already used");
_usedVouchers.push(voucherId);
for(uint i = 0; i < tokenQty; i++) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_safeMint(msg.sender, newItemId);
}
}
// Contract level metadata
function contractURI() public view returns (string memory) {
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, "contract")) : "";
}
function getMessageHash(address _address, uint256 _spots, uint256 _voucherId)
public
pure
returns (bytes32)
{
return keccak256(abi.encodePacked(_address, _spots, _voucherId));
}
function getEthSignedMessageHash(bytes32 _messageHash)
public
pure
returns (bytes32)
{
/*
Signature is produced by signing a keccak256 hash with the following format:
"\x19Ethereum Signed Message\n" + len(msg) + msg
*/
return
keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash)
);
}
function verify(bytes memory signature, uint256 spots, uint256 voucherId)
private
view
returns (bool)
{
bytes32 messageHash = getMessageHash(msg.sender, spots, voucherId);
bytes32 ethSignedMessageHash = getEthSignedMessageHash(messageHash);
address signer = recoverSigner(ethSignedMessageHash, signature);
// Check if the signer is any of the contract valid signers
for (uint i = 0; i < _signers.length; i++) {
if (_signers[i] == signer) {
return true;
}
}
return false;
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)
public
pure
returns (address)
{
(bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature);
return ecrecover(_ethSignedMessageHash, v, r, s);
}
function splitSignature(bytes memory sig)
public
pure
returns (
bytes32 r,
bytes32 s,
uint8 v
)
{
require(sig.length == 65, "invalid signature length");
assembly {
/*
First 32 bytes stores the length of the signature
add(sig, 32) = pointer of sig + 32
effectively, skips first 32 bytes of signature
mload(p) loads next 32 bytes starting at the memory address p into memory
*/
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
// implicitly return (r, s, v)
}
} | contractURI | function contractURI() public view returns (string memory) {
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, "contract")) : "";
}
| // Contract level metadata | LineComment | v0.8.7+commit.e28d00a7 | {
"func_code_index": [
2312,
2521
]
} | 7,098 |
||||
AkulaInu | openzeppelin-solidity\contracts\utils\Address.sol | 0x4f8ed47f839e079be0a79b95d0fd5473c90804d0 | Solidity | Address | library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
} | /**
* @dev Collection of functions related to the address type
*/ | NatSpecMultiLine | isContract | function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
| /**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/ | NatSpecMultiLine | v0.6.2+commit.bacdbe57 | None | ipfs://36acfd850d1a2fda2fc855c17ea6964ae99204c9d3a51b35ba8958489722da1b | {
"func_code_index": [
606,
1230
]
} | 7,099 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.