eth-accounts-index/solidity/AccountsIndex.sol

173 lines
4.4 KiB
Solidity
Raw Permalink Normal View History

pragma solidity >=0.8.0;
2020-11-13 18:33:39 +01:00
// SPDX-License-Identifier: AGPL-3.0-or-later
// File-Version: 3
2020-11-13 18:33:39 +01:00
contract AccountsIndex {
2023-02-12 08:51:58 +01:00
uint256 constant blockedField = 1 << 128;
address[] entryList;
mapping(address => uint256) entryIndex;
// Implements Writer
2024-04-15 12:23:34 +02:00
mapping(address => bool) public writers;
// Implements ERC173
2021-04-30 11:36:56 +02:00
address public owner;
2020-11-13 18:33:39 +01:00
// Implements AccountsIndex
event AddressAdded(address _account); // AccountsIndex
// Implements AccountsIndexMutable
event AddressActive(address indexed _account, bool _active);
// Implements AccountsIndexMutable
event AddressRemoved(address _account);
// Implements ERC173
2021-04-30 11:36:56 +02:00
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); // EIP173
// Implements Writer
event WriterAdded(address _account); // AccountsIndex
// Implements Writer
event WriterDeleted(address _account);
2020-11-13 18:33:39 +01:00
2023-03-17 22:35:12 +01:00
constructor() {
2020-11-13 18:33:39 +01:00
owner = msg.sender;
2023-02-12 08:51:58 +01:00
entryList.push(address(0));
2023-02-12 07:07:14 +01:00
}
// Implements AccountsIndex
2023-03-17 22:35:12 +01:00
function entryCount() external view returns (uint256) {
2023-02-12 08:51:58 +01:00
return entryList.length - 1;
2020-11-13 18:33:39 +01:00
}
// Implements Writer
function addWriter(address _writer) public returns (bool) {
2023-03-26 09:12:50 +02:00
require(owner == msg.sender, 'ERR_AXX');
2024-04-15 12:23:34 +02:00
writers[_writer] = true;
emit WriterAdded(_writer);
return true;
2020-11-13 18:33:39 +01:00
}
// Implements Writer
function deleteWriter(address _writer) public returns (bool) {
2023-03-26 09:12:50 +02:00
require(owner == msg.sender, 'ERR_AXX');
2024-04-15 12:23:34 +02:00
delete writers[_writer];
emit WriterDeleted(_writer);
return true;
2020-11-13 18:33:39 +01:00
}
2024-04-15 12:23:34 +02:00
// Implements Writer
function isWriter(address _writer) public view returns (bool) {
return writers[_writer] || _writer == owner;
}
// Implements AccountsIndex
function add(address _account) external returns (bool) {
uint256 i;
2023-02-12 08:51:58 +01:00
uint256 _entry;
2024-04-15 12:23:34 +02:00
require(isWriter(msg.sender));
2021-04-30 11:36:56 +02:00
require(entryIndex[_account] == 0);
2023-02-12 08:51:58 +01:00
require(entryList.length < (1 << 64));
i = entryList.length;
entryList.push(_account);
_entry = uint64(i);
_entry |= block.timestamp << 64;
entryIndex[_account] = _entry;
emit AddressAdded(_account);
return true;
}
// Implements AccountsIndexMutable
2023-02-12 08:51:58 +01:00
function remove(address _account) external returns (bool) {
uint256 i;
uint256 l;
2024-04-15 12:23:34 +02:00
require(isWriter(msg.sender), 'ERR_AXX');
2023-03-26 09:12:50 +02:00
require(this.have(_account), 'ERR_ACL');
2023-02-12 08:51:58 +01:00
l = entryList.length - 1;
i = entryIndex[_account];
if (i < l) {
entryList[i] = entryList[l];
}
entryList.pop();
entryIndex[_account] = 0;
emit AddressRemoved(_account);
2023-02-12 08:51:58 +01:00
return true;
}
// Implements AccountsIndexMutable
function activate(address _account) external returns (bool) {
2024-04-15 12:23:34 +02:00
require(isWriter(msg.sender), 'ERR_AXX');
2023-03-26 09:12:50 +02:00
require(entryIndex[_account] > 0, 'ERR_NOT_FOUND');
require(entryIndex[_account] & blockedField == blockedField, 'ERR_NOT_BLOCKED');
2023-02-12 08:51:58 +01:00
entryIndex[_account] >>= 129;
emit AddressActive(_account, true);
2023-03-17 22:35:12 +01:00
return true;
}
// Implements AccountsIndexMutable
2023-02-12 08:51:58 +01:00
function deactivate(address _account) external returns (bool) {
2024-04-15 12:23:34 +02:00
require(isWriter(msg.sender));
2023-03-26 09:12:50 +02:00
require(entryIndex[_account] > 0, 'ERR_NOT_FOUND');
require(entryIndex[_account] & blockedField == 0, 'ERR_NOT_ACTIVE');
2023-02-12 08:51:58 +01:00
entryIndex[_account] <<= 129;
entryIndex[_account] |= blockedField;
emit AddressActive(_account, false);
2023-02-12 08:51:58 +01:00
return true;
}
// Implements AccountsIndex
2023-03-17 22:35:12 +01:00
function entry(uint256 _i) external view returns (address) {
2023-02-12 08:51:58 +01:00
return entryList[_i + 1];
}
// Implements AccountsIndex
2023-03-17 22:35:12 +01:00
function time(address _account) external view returns (uint256) {
2023-02-12 08:51:58 +01:00
require(entryIndex[_account] > 0);
return entryIndex[_account] >> 64;
}
// Implements AccountsIndex
2023-02-05 05:54:50 +01:00
function have(address _account) external view returns (bool) {
return entryIndex[_account] > 0;
2021-04-30 11:36:56 +02:00
}
// Implements AccountsIndexMutable
function isActive(address _account) external view returns (bool) {
2023-02-12 07:07:14 +01:00
return this.have(_account) && entryIndex[_account] & blockedField != blockedField;
}
// Implements EIP173
2021-04-30 11:36:56 +02:00
function transferOwnership(address _newOwner) public returns (bool) {
address oldOwner;
2023-03-26 09:12:50 +02:00
require(msg.sender == owner, 'ERR_AXX');
2021-04-30 11:36:56 +02:00
oldOwner = owner;
owner = _newOwner;
2021-04-30 11:36:56 +02:00
emit OwnershipTransferred(oldOwner, owner);
2023-03-17 22:35:12 +01:00
return true;
2021-04-30 11:36:56 +02:00
}
// Implements EIP165
2021-04-30 11:36:56 +02:00
function supportsInterface(bytes4 _sum) public pure returns (bool) {
if (_sum == 0xb7bca625) { // AccountsIndex
return true;
}
if (_sum == 0x9479f0ae) { // AccountsIndexMutable
2021-04-30 11:36:56 +02:00
return true;
}
if (_sum == 0x01ffc9a7) { // EIP165
return true;
}
if (_sum == 0x9493f8b2) { // EIP173
return true;
}
if (_sum == 0xabe1f1f5) { // Writer
2021-10-24 15:25:33 +02:00
return true;
}
2021-04-30 11:36:56 +02:00
return false;
2020-11-13 18:33:39 +01:00
}
}