@etherisc/gif-next 0.0.2-fe88ad7-208 → 0.0.2-fe8cf39-182

package/contracts/authorization/AccessManagerCloneable.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {AccessManagerUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagerUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
+
+import {InitializableERC165} from "../shared/InitializableERC165.sol";
+import {RegistryLinked} from "../shared/RegistryLinked.sol";
+import {VersionPart, VersionLib} from "../type/Version.sol";
+
+
+/// @dev An AccessManager based on OpenZeppelin that is cloneable and has a central lock property.
+/// The lock property allows to lock all services of a release in a central place.
+/// Cloned by upon release preparation and instance cloning.
+contract AccessManagerCloneable is
+    AccessManagerUpgradeable,
+    InitializableERC165,
+    RegistryLinked
+{
+    error ErrorAccessManagerCallerNotAdmin(address caller);
+    error ErrorAccessManagerRegistryAlreadySet(address registry);
+    error ErrorAccessManagerInvalidRelease(VersionPart release);
+
+    error ErrorAccessManagerTargetAdminLocked(address target);
+    error ErrorAccessManagerCallerAdminLocked(address caller);
+
+    VersionPart private _release;
+    bool private _isLocked;
+
+    modifier onlyAdminRole() {
+        (bool isMember, ) = hasRole(ADMIN_ROLE, msg.sender);
+        if(!isMember) {
+            revert ErrorAccessManagerCallerNotAdmin(msg.sender);
+        }
+        _;
+    }
+
+    function initialize(address admin)
+        external
+        initializer()
+    {
+        __AccessManager_init(admin);
+        _initializeERC165();
+        _registerInterface(type(IAccessManager).interfaceId);
+    }
+
+
+    /// @dev Completes the setup of the access manager.
+    /// Links the access manager to the registry and sets the release version.
+    function completeSetup(
+        address registry, 
+        VersionPart release
+    )
+        external
+        onlyAdminRole
+        reinitializer(uint64(release.toInt()))
+    {
+        _completeSetup(registry, release, true);
+    }
+
+    /// @dev Completes the setup of the access manager.
+    /// Links the access manager to the registry and sets the release version.
+    function completeSetup(
+        address registry, 
+        VersionPart release,
+        bool verifyRelease
+    )
+        public
+        onlyAdminRole
+        reinitializer(uint64(release.toInt()))
+    {
+        _completeSetup(registry, release, verifyRelease);
+    }
+
+    /// @dev Returns true if the caller is authorized to call the target with the given selector and the manager lock is not set to locked.
+    /// Feturn values as in OpenZeppelin AccessManager.
+    /// For a locked manager the function reverts with ErrorAccessManagerTargetAdminLocked.
+    function canCall(
+        address caller,
+        address target,
+        bytes4 selector
+    )
+        public 
+        view 
+        virtual override 
+        returns (
+            bool immediate, 
+            uint32 delay
+        ) 
+    {
+        (immediate, delay) = super.canCall(caller, target, selector);
+
+        // locking of all contracts under control of this access manager
+        if (isLocked()) {
+            revert ErrorAccessManagerTargetAdminLocked(target);
+        }
+    }
+
+
+    /// @dev Locks/unlocks all services of this access manager.
+    /// Only the corresponding access admin can lock/unlock the services.
+    function setLocked(bool locked)
+        external
+        onlyAdminRole() 
+    {
+        _isLocked = locked;
+    }
+
+
+    /// @dev Returns the release version of this access manager.
+    /// For the registry admin release 3 is returned.
+    /// For the release admin and the instance admin the actual release version is returned.
+    function getRelease() external view returns (VersionPart release) {
+        return _release;
+    }
+
+
+    /// @dev Returns true iff all contracts of this access manager are locked.
+    function isLocked()
+        public
+        view
+        returns (bool)
+    {
+        return _isLocked;
+    }
+
+
+    function _completeSetup(
+        address registry,
+        VersionPart release,
+        bool verifyRelease
+    )
+        internal
+    {
+        // checks
+        if(address(getRegistry()) != address(0)) {
+            revert ErrorAccessManagerRegistryAlreadySet(address(getRegistry()) );
+        }
+
+        if (verifyRelease && !release.isValidRelease()) {
+            revert ErrorAccessManagerInvalidRelease(release);
+        }
+
+        // effects
+        __RegistryLinked_init(registry);
+        _release = release;
+    }
+}

package/contracts/authorization/Authorization.sol

@@ -0,0 +1,337 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "./IAccess.sol";
+import {IAuthorization} from "./IAuthorization.sol";
+import {ObjectType, ObjectTypeLib, PRODUCT, ORACLE, DISTRIBUTION, POOL} from "../type/ObjectType.sol";
+import {RoleId, RoleIdLib, ADMIN_ROLE} from "../type/RoleId.sol";
+import {SelectorLib} from "../type/Selector.sol";
+import {Str, StrLib} from "../type/String.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
+
+contract Authorization
+    is IAuthorization
+{
+    uint256 public constant GIF_RELEASE = 3;
+
+    string public constant ROLE_NAME_SUFFIX = "Role";
+    string public constant SERVICE_ROLE_NAME_SUFFIX = "ServiceRole";
+
+    ObjectType[] internal _serviceDomains;
+    mapping(ObjectType domain => Str target) internal _serviceTarget;
+
+    string internal _mainTargetName = "Component";
+    string internal _tokenHandlerName = "ComponentTH";
+
+    Str internal _mainTarget;
+    Str internal _tokenHandlerTarget;
+    Str[] internal _targets;
+
+    mapping(Str target => RoleId roleid) internal _targetRole;
+    mapping(Str target => bool exists) internal _targetExists;
+
+    RoleId[] internal _roles;
+    mapping(RoleId role => RoleInfo info) internal _roleInfo;
+
+    mapping(Str target => RoleId[] authorizedRoles) internal _authorizedRoles;
+    mapping(Str target => mapping(RoleId authorizedRole => IAccess.FunctionInfo[] functions)) internal _authorizedFunctions;
+
+
+    constructor(
+        string memory mainTargetName, 
+        ObjectType targetDomain
+    )
+    {
+        // checks
+        if (bytes(mainTargetName).length == 0) {
+            revert ErrorAuthorizationMainTargetNameEmpty();
+        }
+
+        if (targetDomain.eqz()) {
+            revert ErrorAuthorizationTargetDomainZero();
+        }
+
+        // effects
+        // setup main target, main role id and main role info
+        _mainTargetName = mainTargetName;
+        _tokenHandlerName = string(abi.encodePacked(mainTargetName, "TH"));
+
+        RoleId mainRoleId = RoleIdLib.toComponentRoleId(targetDomain, 0);
+        string memory mainRolName = _toTargetRoleName(mainTargetName);
+
+        _addTargetWithRole(
+            _mainTargetName, 
+            mainRoleId,
+            mainRolName);
+
+        _mainTarget = StrLib.toStr(mainTargetName);
+        _targetRole[_mainTarget] = mainRoleId;
+
+        // add token handler target for components
+        if (targetDomain == PRODUCT() 
+            || targetDomain == DISTRIBUTION()
+            || targetDomain == ORACLE()
+            || targetDomain == POOL()
+        ) {
+            _addTarget(_tokenHandlerName);
+        }
+
+        // setup token handler target
+        _tokenHandlerTarget = StrLib.toStr(_tokenHandlerName);
+
+        // setup use case specific parts
+        _setupServiceTargets();
+        _setupRoles(); // not including main target role
+        _setupTargets(); // not including main target (and token handler target)
+
+        _setupTokenHandlerAuthorizations();
+        _setupTargetAuthorizations(); // not including token handler target
+    }
+
+    function getServiceDomains() external view returns(ObjectType[] memory serviceDomains) {
+        return _serviceDomains;
+    }
+
+    function getComponentRole(ObjectType componentDomain) public view returns(RoleId roleId) {
+        return RoleIdLib.toComponentRoleId(componentDomain, 0);
+    }
+
+    function getServiceRole(ObjectType serviceDomain) public virtual pure returns (RoleId serviceRoleId) {
+        return RoleIdLib.roleForTypeAndVersion(
+            serviceDomain, 
+            getRelease());
+    }
+
+    function getServiceTarget(ObjectType serviceDomain) external view returns(Str serviceTarget) {
+        return _serviceTarget[serviceDomain];
+    }
+
+    function getRoles() external view returns(RoleId[] memory roles) {
+        return _roles;
+    }
+
+    function roleExists(RoleId roleId) public view returns(bool exists) {
+        return _roleInfo[roleId].roleType != RoleType.Undefined;
+    }
+
+    function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory info) {
+        return _roleInfo[roleId];
+    }
+
+    function getMainTargetName() public virtual view returns (string memory name) {
+        return _mainTargetName;
+    }
+
+    function getMainTarget() public view returns(Str) {
+        return _mainTarget;
+    }
+
+    function getTokenHandlerName() public view returns(string memory) {
+        return _tokenHandlerName;
+    }
+
+    function getTokenHandlerTarget() public view returns(Str) {
+        return _tokenHandlerTarget;
+    }
+
+    function getTarget(string memory targetName) public view returns(Str target) {
+        return StrLib.toStr(targetName);
+    }
+
+    function getTargets() external view returns(Str[] memory targets) {
+        return _targets;
+    }
+
+    function targetExists(Str target) external view returns(bool exists) {
+        return target == _mainTarget || _targetExists[target];
+    }
+
+    function getTargetRole(Str target) external view returns(RoleId roleId) {
+        return _targetRole[target];
+    }
+
+    function getAuthorizedRoles(Str target) external view returns(RoleId[] memory roleIds) {
+        return _authorizedRoles[target];
+    }
+
+    function getAuthorizedFunctions(Str target, RoleId roleId) external view returns(IAccess.FunctionInfo[] memory authorizatedFunctions) {
+        return _authorizedFunctions[target][roleId];
+    }
+
+    function getRelease() public virtual pure returns(VersionPart release) {
+        return VersionPartLib.toVersionPart(GIF_RELEASE);
+    }
+
+    /// @dev Sets up the relevant service targets for the component.
+    /// Overwrite this function for use case specific authorizations.
+    function _setupServiceTargets() internal virtual { }
+
+    /// @dev Sets up the relevant (non-service) targets for the component.
+    /// Overwrite this function for use case specific authorizations.
+    function _setupTargets() internal virtual { }
+
+    /// @dev Sets up the relevant roles for the component.
+    /// Overwrite this function for use case specific authorizations.
+    function _setupRoles() internal virtual {}
+
+    /// @dev Sets up the relevant component's token handler authorizations.
+    /// Overwrite this function for use case specific authorizations.
+    function _setupTokenHandlerAuthorizations() internal virtual {}
+
+    /// @dev Sets up the relevant target authorizations for the component.
+    /// Overwrite this function for use case specific authorizations.
+    function _setupTargetAuthorizations() internal virtual {}
+
+    /// @dev Add the service target role for the specified service domain
+    function _addServiceTargetWithRole(ObjectType serviceDomain) internal {
+        // add service domain
+        _serviceDomains.push(serviceDomain);
+
+        // get versioned target name
+        string memory serviceTargetName = ObjectTypeLib.toVersionedName(
+                ObjectTypeLib.toName(serviceDomain), 
+                "Service", 
+                getRelease().toInt());
+
+        _serviceTarget[serviceDomain] = StrLib.toStr(serviceTargetName);
+
+        RoleId serviceRoleId = getServiceRole(serviceDomain);
+        string memory serviceRoleName = ObjectTypeLib.toVersionedName(
+                ObjectTypeLib.toName(serviceDomain), 
+                "ServiceRole", 
+                getRelease().toInt());
+
+        _addTargetWithRole(
+            serviceTargetName,
+            serviceRoleId,
+            serviceRoleName);
+    }
+
+
+    /// @dev Use this method to to add an authorized role.
+    function _addRole(RoleId roleId, RoleInfo memory info) internal {
+        _roles.push(roleId);
+        _roleInfo[roleId] = info;
+    }
+
+
+    /// @dev Add a contract role for the provided role id and name.
+    function _addContractRole(RoleId roleId, string memory name) internal {
+        _addRole(
+            roleId,
+            _toRoleInfo(
+                ADMIN_ROLE(),
+                RoleType.Contract,
+                1,
+                name));
+    }
+
+
+    /// @dev Add the versioned service role for the specified service domain
+    function _addServiceRole(ObjectType serviceDomain) internal {
+        _addContractRole(
+            getServiceRole(serviceDomain),
+            ObjectTypeLib.toVersionedName(
+                ObjectTypeLib.toName(serviceDomain), 
+                SERVICE_ROLE_NAME_SUFFIX, 
+                getRelease().toInt()));
+    }
+
+
+    /// @dev Add a contract role for the provided role id and name.
+    function _addCustomRole(RoleId roleId, RoleId adminRoleId, uint32 maxMemberCount, string memory name) internal {
+        _addRole(
+            roleId,
+            _toRoleInfo(
+                adminRoleId,
+                RoleType.Custom,
+                maxMemberCount,
+                name));
+    }
+
+
+    /// @dev Use this method to to add an authorized target together with its target role.
+    function _addTargetWithRole(
+        string memory targetName, 
+        RoleId roleId, 
+        string memory roleName
+    )
+        internal
+    {
+        // add target
+        Str target = StrLib.toStr(targetName);
+        _targets.push(target);
+
+        _targetExists[target] = true;
+
+        // link role to target if defined
+        if (roleId != RoleIdLib.zero()) {
+            // add role if new
+            if (!roleExists(roleId)) {
+                _addContractRole(roleId, roleName);
+            }
+
+            // link target to role
+            _targetRole[target] = roleId;
+        }
+    }
+
+
+    /// @dev Use this method to to add an authorized target.
+    function _addTarget(string memory name) internal {
+        _addTargetWithRole(name, RoleIdLib.zero(), "");
+    }
+
+
+    /// @dev Use this method to authorize the specified role to access the target.
+    function _authorizeForTarget(string memory target, RoleId authorizedRoleId)
+        internal
+        returns (IAccess.FunctionInfo[] storage authorizatedFunctions)
+    {
+        Str targetStr = StrLib.toStr(target);
+        _authorizedRoles[targetStr].push(authorizedRoleId);
+        return _authorizedFunctions[targetStr][authorizedRoleId];
+    }
+
+
+    /// @dev Use this method to authorize a specific function authorization
+    function _authorize(IAccess.FunctionInfo[] storage functions, bytes4 selector, string memory name) internal {
+        functions.push(
+            IAccess.FunctionInfo({
+                selector: SelectorLib.toSelector(selector),
+                name: StrLib.toStr(name),
+                createdAt: TimestampLib.blockTimestamp()}));
+    }
+
+
+    /// @dev role id for targets registry, staking and instance
+    function _toTargetRoleId(ObjectType targetDomain) 
+        internal
+        pure
+        returns (RoleId targetRoleId)
+    {
+        return RoleIdLib.roleForType(targetDomain);
+    }
+
+
+    function _toTargetRoleName(string memory targetName) internal pure returns (string memory) {
+        return string(
+            abi.encodePacked(
+                targetName,
+                ROLE_NAME_SUFFIX));
+    }
+
+
+    /// @dev creates a role info object from the provided parameters
+    function _toRoleInfo(RoleId adminRoleId, RoleType roleType, uint32 maxMemberCount, string memory name) internal view returns (RoleInfo memory info) {
+        return RoleInfo({
+            name: StrLib.toStr(name),
+            adminRoleId: adminRoleId,
+            roleType: roleType,
+            maxMemberCount: maxMemberCount,
+            createdAt: TimestampLib.blockTimestamp(),
+            pausedAt: TimestampLib.max()});
+    }
+}
+

package/contracts/authorization/IAccess.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {RoleId} from "../type/RoleId.sol";
+import {Selector} from "../type/Selector.sol";
+import {Str} from "../type/String.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IAccess {
+
+    enum RoleType {
+        Undefined, // no role must have this type
+        Contract, // roles assigned to contracts, cannot be revoked
+        Gif, // framework roles that may be freely assigned and revoked
+        Custom // use case specific rules for components
+    }
+
+    struct RoleInfo {
+        RoleId adminRoleId;
+        RoleType roleType;
+        uint32 maxMemberCount;
+        Str name;
+        Timestamp createdAt;
+        Timestamp pausedAt;
+    }
+
+    struct TargetInfo {
+        Str name;
+        bool isCustom;
+        Timestamp createdAt;
+    }
+
+    struct FunctionInfo {
+        Str name; // function name
+        Selector selector; // function selector
+        Timestamp createdAt;
+    }
+
+    struct RoleNameInfo {
+        RoleId roleId;
+        bool exists;
+    }
+
+    struct TargeNameInfo {
+        address target;
+        bool exists;
+    }
+
+}

package/contracts/authorization/IAccessAdmin.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {IAccess} from "./IAccess.sol";
+import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {Selector} from "../type/Selector.sol";
+import {Str} from "../type/String.sol";
+import {VersionPart} from "../type/Version.sol";
+
+interface IAccessAdmin is 
+    IAccessManaged,
+    IAccess,
+    IRegistryLinked
+{
+
+    // roles, targets and functions
+    event LogAccessAdminRoleCreated(RoleId roleId, RoleType roleType, RoleId roleAdminId, string name);
+    event LogAccessAdminTargetCreated(address target, string name);
+
+    event LogAccessAdminRoleGranted(address account, string roleName);
+    event LogAccessAdminRoleRevoked(address account, string roleName);
+    event LogAccessAdminFunctionGranted(address target, string functionName, string roleName);
+
+    // only deployer modifier
+    error ErrorNotDeployer();
+
+    // only role admin modifier
+    error ErrorNotAdminOfRole(RoleId adminRoleId);
+
+    // only role owner modifier
+    error ErrorNotRoleOwner(RoleId roleId);
+
+    // initialize authority
+    error ErrorAdminRoleMissing();
+
+    // create role
+    error ErrorRoleAlreadyCreated(RoleId roleId, string name);
+    error ErrorRoleAdminNotExisting(RoleId adminRoleId);
+    error ErrorRoleNameEmpty(RoleId roleId);
+    error ErrorRoleNameAlreadyExists(RoleId roleId, string name, RoleId existingRoleId);
+
+    // grant/revoke/renounce role
+    error ErrorRoleUnknown(RoleId roleId);
+    error ErrorRoleIsLocked(RoleId roleId);
+    error ErrorRoleIsPaused(RoleId roleId);
+    error ErrorRoleMembersLimitReached(RoleId roleId, uint256 memberCountLimit);
+    error ErrorRoleMemberNotContract(RoleId roleId, address notContract);
+    error ErrorRoleMemberRemovalDisabled(RoleId roleId, address expectedMember);
+
+    // create target
+    error ErrorTargetAlreadyCreated(address target, string name);
+    error ErrorTargetNameEmpty(address target);
+    error ErrorTargetNameAlreadyExists(address target, string name, address existingTarget);
+    error ErrorTargetNotAccessManaged(address target);
+    error ErrorTargetAuthorityMismatch(address expectedAuthority, address actualAuthority);
+
+    // lock target
+    error ErrorTagetNotLockable();
+    error ErrorTargetAlreadyLocked(address target, bool isLocked);
+
+    // authorize target functions
+    error ErrorAuthorizeForAdminRoleInvalid(address target);
+
+    // check target
+    error ErrorTargetUnknown(address target);
+
+    /// @dev Set the disabled status of the speicified role.
+    /// Role disabling only prevents the role from being granted to new accounts.
+    /// Existing role members may still execute functions that are authorized for that role.
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    // TODO move to instance admin
+    // function setRoleDisabled(RoleId roleId, bool disabled) external;
+
+    /// @dev Grant the specified account the provided role.
+    /// Permissioned: the caller must have the roles admin role.
+    // TODO move to instance admin
+    // function grantRole(address account, RoleId roleId) external;
+
+    /// @dev Revoke the provided role from the specified account.
+    /// Permissioned: the caller must have the roles admin role.
+    // TODO move to instance admin
+    // function revokeRole(address account, RoleId roleId) external;
+
+    /// @dev Removes the provided role from the caller
+    // TODO move to instance admin
+    // function renounceRole(RoleId roleId) external;
+
+    /// @dev Set the locked status of the speicified contract.
+    /// IMPORTANT: using this function the AccessManager might itself be put into locked state from which it cannot be unlocked again.
+    /// Overwrite this function if a different use case specific behaviour is required.
+    /// Alternatively, add specific function to just unlock this contract without a restricted() modifier.
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    // TODO move to instance admin
+    // function setTargetLocked(address target, bool locked) external;
+
+    /// @dev Specifies which functions of the target can be accessed by the provided role.
+    /// Previously existing authorizations will be overwritten.
+    /// Authorizing the admin role is not allowed, use function unauthorizedFunctions for this.
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    // TODO move to instance admin
+    // function authorizeFunctions(address target, RoleId roleId, FunctionInfo[] memory functions) external;
+
+    /// @dev Specifies for which functionss to remove any previous authorization
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    // TODO move to instance admin
+    // function unauthorizeFunctions(address target, FunctionInfo[] memory functions) external;
+
+    //--- view functions ----------------------------------------------------//
+
+    function getRelease() external view returns (VersionPart release);
+
+    function roles() external view returns (uint256 numberOfRoles);
+    function getRoleId(uint256 idx) external view returns (RoleId roleId);
+    function getAdminRole() external view returns (RoleId roleId);
+    function getPublicRole() external view returns (RoleId roleId);
+
+    function roleExists(RoleId roleId) external view returns (bool exists); 
+    function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory roleInfo);
+    function getRoleForName(Str name) external view returns (RoleNameInfo memory);
+
+    function hasRole(address account, RoleId roleId) external view returns (bool);
+    function hasAdminRole(address account, RoleId roleId) external view returns (bool);
+    function roleMembers(RoleId roleId) external view returns (uint256 numberOfMembers);
+    function getRoleMember(RoleId roleId, uint256 idx) external view returns (address account);
+
+    function targetExists(address target) external view returns (bool exists);
+    function isTargetLocked(address target) external view returns (bool locked);
+    function targets() external view returns (uint256 numberOfTargets);
+    function getTargetAddress(uint256 idx) external view returns (address target);
+    function getTargetInfo(address target) external view returns (TargetInfo memory targetInfo);
+    function getTargetForName(Str name) external view returns (address target);
+
+    function authorizedFunctions(address target) external view returns (uint256 numberOfFunctions);
+    function getAuthorizedFunction(address target, uint256 idx) external view returns (FunctionInfo memory func, RoleId roleId);
+    function canCall(address caller, address target, Selector selector) external view returns (bool can);
+
+    function toRole(RoleId adminRoleId, RoleType roleType, uint32 maxMemberCount, string memory name) external view returns (RoleInfo memory);
+    function toFunction(bytes4 selector, string memory name) external view returns (FunctionInfo memory);
+    function deployer() external view returns (address);
+}