@etherisc/gif-next 0.0.2-f634e5c-828 → 0.0.2-f677999-878

package/contracts/authorization/Authorization.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.20;
 
 import {IAccess} from "./IAccess.sol";
 import {IAuthorization} from "./IAuthorization.sol";
-import {ObjectType, ObjectTypeLib} from "../type/ObjectType.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";
@@ -22,6 +22,10 @@ contract Authorization
     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;
@@ -34,256 +38,300 @@ contract Authorization
     mapping(Str target => mapping(RoleId authorizedRole => IAccess.FunctionInfo[] functions)) internal _authorizedFunctions;
 
 
-    constructor(string memory mainTargetName) {
+    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();
-        _setupTargets();
-        _setupTargetAuthorizations();
+        _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 getServiceDomains() external view returns(ObjectType[] memory serviceDomains) {
-          return _serviceDomains;
-     }
+    function getServiceTarget(ObjectType serviceDomain) external view returns(Str serviceTarget) {
+        return _serviceTarget[serviceDomain];
+    }
 
-     function getServiceRole(ObjectType serviceDomain) public virtual pure returns (RoleId serviceRoleId) {
-          return RoleIdLib.roleForTypeAndVersion(
-               serviceDomain, 
-               getRelease());
-     }
+    function getRoles() external view returns(RoleId[] memory roles) {
+        return _roles;
+    }
 
-     function getServiceTarget(ObjectType serviceDomain) external view returns(Str serviceTarget) {
-          return _serviceTarget[serviceDomain];
-     }
+    function roleExists(RoleId roleId) public view returns(bool exists) {
+        return _roleInfo[roleId].roleType != RoleType.Undefined;
+    }
 
-     function getRoles() external view returns(RoleId[] memory roles) {
-          return _roles;
-     }
+    function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory info) {
+        return _roleInfo[roleId];
+    }
 
-     function roleExists(RoleId roleId) public view returns(bool exists) {
-          return _roleInfo[roleId].roleType != RoleType.Undefined;
-     }
+    function getMainTargetName() public virtual view returns (string memory name) {
+        return _mainTargetName;
+    }
 
-     function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory info) {
-          return _roleInfo[roleId];
-     }
+    function getMainTarget() public view returns(Str) {
+        return _mainTarget;
+    }
 
-     function getTargetName() public virtual view returns (string memory name) {
-          return _mainTargetName;
-     }
+    function getTokenHandlerName() public view returns(string memory) {
+        return _tokenHandlerName;
+    }
 
-     function getMainTarget() public view returns(Str) {
-          return getTarget(_mainTargetName);
-     }
+    function getTokenHandlerTarget() public view returns(Str) {
+        return _tokenHandlerTarget;
+    }
 
-     function getTarget(string memory targetName) public view returns(Str target) {
-          return StrLib.toStr(targetName);
-     }
+    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 getTargets() external view returns(Str[] memory targets) {
+        return _targets;
+    }
 
-     function targetExists(Str target) external view returns(bool exists) {
-          return _targetExists[target];
-     }
+    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 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 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 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 a specific component.
-     function _setupServiceTargets() internal virtual { }
-
-     /// @dev Sets up the relevant (non-service) targets for the component.
-     /// Overwrite this function for a specific component.
-     function _setupTargets() internal virtual { }
-
-     /// @dev Sets up the relevant roles for the component.
-     /// Overwrite this function for a specific component.
-     function _setupRoles() internal virtual {}
-
-     /// @dev Sets up the relevant target authorizations for the component.
-     /// Overwrite this function for a specific realease.
-     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()));
-     }
-
-
-     function _addComponentTargetWithRole(ObjectType componentType) internal {
-          _addComponentTargetWithRole(componentType, 0);
-     }
-
-
-     function _addComponentTargetWithRole(ObjectType componentType, uint64 index) internal {
-          _addTargetWithRole(
-               getTargetName(), 
-               RoleIdLib.toComponentRoleId(componentType, index),
-               _toTargetRoleName(
-                    getTargetName()));
-     }
-
-
-     /// @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()});
-     }
+    /// @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/IAccessAdmin.sol

@@ -4,20 +4,25 @@ 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 {Timestamp} from "../type/Timestamp.sol";
+import {VersionPart} from "../type/Version.sol";
 
 interface IAccessAdmin is 
     IAccessManaged,
-    IAccess
+    IAccess,
+    IRegistryLinked
 {
 
-    // roles
-    event LogRoleCreated(RoleId roleId, RoleType roleType, RoleId roleAdminId, string name);
-    event LogTargetCreated(address target, string name);
-    event LogFunctionCreated(address target, Selector selector, string name);
+    // 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();
@@ -29,7 +34,6 @@ interface IAccessAdmin is
     error ErrorNotRoleOwner(RoleId roleId);
 
     // initialize authority
-    error ErrorAuthorityAlreadySet();
     error ErrorAdminRoleMissing();
 
     // create role
@@ -106,6 +110,8 @@ interface IAccessAdmin is
 
     //--- 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);

package/contracts/authorization/IAuthorization.sol

@@ -11,6 +11,9 @@ interface IAuthorization is
      IAccess 
 {
 
+     error ErrorAuthorizationMainTargetNameEmpty();
+     error ErrorAuthorizationTargetDomainZero();
+
      /// @dev Returns the list of service targets.
      function getServiceDomains() external view returns(ObjectType[] memory serviceDomains);
 
@@ -20,6 +23,9 @@ interface IAuthorization is
      /// @dev Returns the service target for the specified domain.
      function getServiceTarget(ObjectType serviceDomain) external view returns(Str serviceTarget);
 
+     /// @dev Returns the component role for the specified domain.
+     function getComponentRole(ObjectType componentDomain) external view returns(RoleId componentRoleId);
+
      /// @dev Returns the list of involved roles.
      function getRoles() external view returns(RoleId[] memory roles);
 
@@ -32,11 +38,19 @@ interface IAuthorization is
      /// @dev Returns the main target id name as string.
      /// This name is used to derive the target id and a corresponding target role name
      /// Overwrite this function to change the basic pool target name.
-     function getTargetName() external view returns (string memory name);
+     function getMainTargetName() external view returns (string memory name);
 
      /// @dev Returns the main target.
      function getMainTarget() external view returns(Str target);
 
+     /// @dev Returns the token hander name.
+     /// Only components have a token handler.
+     function getTokenHandlerName() external view returns(string memory name);
+
+     /// @dev Returns the token hander target.
+     /// Only components have a token handler.
+     function getTokenHandlerTarget() external view returns(Str target);
+
      /// @dev Returns the complete list of targets.
      function getTargets() external view returns(Str[] memory targets);