@etherisc/gif-next 0.0.2-e987ccf-894 → 0.0.2-e9c25ee-730

package/contracts/authorization/AccessAdmin.sol

@@ -5,12 +5,30 @@ import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/acce
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
 
-import {AccessManagerCloneable} from "./AccessManagerCloneable.sol";
+import {IAccess} from "./IAccess.sol";
 import {IAccessAdmin} from "./IAccessAdmin.sol";
+import {IAuthorization} from "./IAuthorization.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IService} from "../shared/IService.sol";
+
+import {ADMIN_ROLE_NAME, PUBLIC_ROLE_NAME} from "./AccessAdmin.sol";
+import {AccessAdminLib} from "./AccessAdminLib.sol";
+import {AccessManagerCloneable} from "./AccessManagerCloneable.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 import {RoleId, RoleIdLib, ADMIN_ROLE, PUBLIC_ROLE} from "../type/RoleId.sol";
-import {Selector, SelectorLib, SelectorSetLib} from "../type/Selector.sol";
+import {Selector, SelectorSetLib} from "../type/Selector.sol";
 import {Str, StrLib} from "../type/String.sol";
-import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+import {VersionPart} from "../type/Version.sol";
+
+interface IAccessManagedChecker {
+    function authority() external view returns (address);
+}
+
+function ADMIN_ROLE_NAME() pure returns (string memory) { return "AdminRole"; }
+function PUBLIC_ROLE_NAME() pure returns (string memory) { return "PublicRole"; }
 
 
 /**
@@ -25,16 +43,23 @@ contract AccessAdmin is
 {
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    string public constant ADMIN_ROLE_NAME = "AdminRole";
-    string public constant PUBLIC_ROLE_NAME = "PublicRole";
+    /// @dev admin name used for logging only
+    string internal _adminName;
 
-    /// @dev the OpenZeppelin access manager driving the access admin contract
+    /// @dev the access manager driving the access admin contract
+    /// hold link to registry and release version
     AccessManagerCloneable internal _authority;
 
+    /// @dev the authorization contract used for initial access control
+    IAuthorization internal _authorization;
+
     /// @dev stores the deployer address and allows to create initializers
     /// that are restricted to the deployer address.
     address internal _deployer;
 
+    /// @dev the linked NFT ID
+    NftId internal _linkedNftId;
+
     /// @dev store role info per role id
     mapping(RoleId roleId => RoleInfo info) internal _roleInfo;
 
@@ -65,55 +90,128 @@ contract AccessAdmin is
     /// @dev temporary dynamic functions array
     bytes4[] private _functions;
 
+    // @dev target type specific role id counters
+    mapping(TargetType => uint64) internal _nextRoleId;
+
     modifier onlyDeployer() {
         // special case for cloned AccessAdmin contracts
-        // IMPORTANT cloning and _initializeAuthority needs to be done in a single transaction
+        // IMPORTANT cloning and initialize authority needs to be done in a single transaction
         if (_deployer == address(0)) {
             _deployer = msg.sender;
         }
 
         if (msg.sender != _deployer) {
-            revert ErrorNotDeployer();
+            revert ErrorAccessAdminNotDeployer();
         }
         _;
     }
 
-    modifier onlyRoleAdmin(RoleId roleId) {
-        if (!roleExists(roleId)) {
-            revert ErrorRoleUnknown(roleId);
-        }
 
-        if (!hasAdminRole(msg.sender, roleId)) {
-            revert ErrorNotAdminOfRole(_roleInfo[roleId].adminRoleId);
+    modifier onlyExistingRole(
+        RoleId roleId, 
+        bool onlyActiveRole,
+        bool allowLockedRoles
+    )
+    {
+        if (!allowLockedRoles) {
+            _checkRoleExists(roleId, onlyActiveRole);
         }
         _;
     }
 
-    modifier onlyRoleMember(RoleId roleId) {
-        if (!hasRole(msg.sender, roleId)) {
-            revert ErrorNotRoleOwner(roleId);
-        }
-        _;
-    }
 
-    modifier onlyExistingRole(RoleId roleId) {
-        _checkRoleId(roleId);
+    modifier onlyExistingTarget(address target) {
+        _checkTargetExists(target);
         _;
     }
 
-    modifier onlyExistingTarget(address target) {
-        _checkTarget(target);
-        _;
+    //-------------- initialization functions ------------------------------//
+
+    // event LogAccessAdminDebug(string message);
+
+    /// @dev Initializes this admin with the provided accessManager (and authorization specification).
+    /// Internally initializes access manager with this admin and creates basic role setup.
+    function initialize(
+        address authority,
+        string memory adminName 
+    )
+        public
+        initializer()
+    {
+        __AccessAdmin_init(authority, adminName);
     }
 
-    constructor() {
-        _deployer = msg.sender;
-        _authority = new AccessManagerCloneable();
+
+    function __AccessAdmin_init(
+        address authority, 
+        string memory adminName 
+    )
+        internal
+        onlyInitializing()
+        onlyDeployer()
+    {
+        // checks
+        // check authority is contract
+        if (!ContractLib.isContract(authority)) {
+            revert ErrorAccessAdminAuthorityNotContract(authority);
+        }
+
+        // check name not empty
+        if (bytes(adminName).length == 0) {
+            revert ErrorAccessAdminAccessManagerEmptyName();
+        }
+
+        _authority = AccessManagerCloneable(authority);
         _authority.initialize(address(this));
 
-        _setAuthority(address(_authority)); // set authority for oz access managed
-        _createAdminAndPublicRoles();
-        _disableInitializers();
+        // delayed additional check for authority after its initialization
+        if (!ContractLib.isAuthority(authority)) {
+            revert ErrorAccessAdminAccessManagerNotAccessManager(authority);
+        }
+
+        // effects
+        // set and initialize this access manager contract as
+        // the admin (ADMIN_ROLE) of the provided authority
+        __AccessManaged_init(authority);
+
+        // set name for logging
+        _adminName = adminName;
+
+        // set initial linked NFT ID to zero
+        _linkedNftId = NftIdLib.zero();
+
+        // create admin and public roles
+        _initializeAdminAndPublicRoles();
+    }
+
+
+    function getRelease() public view virtual returns (VersionPart release) {
+        return _authority.getRelease();
+    }
+
+
+    function getRegistry() public view returns (IRegistry registry) {
+        return _authority.getRegistry();
+    }
+
+
+    function getLinkedNftId() external view returns (NftId linkedNftId) {
+        return _linkedNftId;
+    }
+
+
+    function getLinkedOwner() external view returns (address linkedOwner) {
+        return getRegistry().ownerOf(_linkedNftId);
+    }
+
+
+    function getAuthorization() public view returns (IAuthorization authorization) {
+        return _authorization;
+    }
+
+
+    function isLocked() public view returns (bool locked) {
+        return _authority.isLocked();
     }
 
     //--- view functions for roles ------------------------------------------//
@@ -134,16 +232,39 @@ contract AccessAdmin is
         return RoleId.wrap(_authority.PUBLIC_ROLE());
     }
 
+    function roleExists(Str roleName) public view returns (bool exists) {
+        // special case admin adn public roles always exist
+        if (roleName == StrLib.toStr(ADMIN_ROLE_NAME()) || roleName == StrLib.toStr(PUBLIC_ROLE_NAME())) {
+            return true;
+        }
+
+        // check if a role id for the name exists
+        RoleId roleId = _roleForName[roleName].roleId;
+        if (roleId.eqz()) {
+            return false;
+        }
+
+        return _roleInfo[roleId].createdAt.gtz();
+    }
+
     function roleExists(RoleId roleId) public view returns (bool exists) {
         return _roleInfo[roleId].createdAt.gtz();
     }
 
-    function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory) {
+    function getRoleForName(string memory name) public view returns (RoleId roleId) {
+        return _roleForName[StrLib.toStr(name)].roleId;
+    }
+
+    function getRoleInfo(RoleId roleId) public view returns (RoleInfo memory) {
         return _roleInfo[roleId];
     }
 
-    function getRoleForName(Str name) external view returns (RoleNameInfo memory) {
-        return _roleForName[name];
+    function isRoleActive(RoleId roleId) external view returns (bool isActive) {
+        return _roleInfo[roleId].pausedAt > TimestampLib.blockTimestamp();
+    }
+
+    function isRoleCustom(RoleId roleId) external view returns (bool isActive) {
+        return _roleInfo[roleId].roleType == RoleType.Custom;
     }
 
     function roleMembers(RoleId roleId) external view returns (uint256 numberOfMembers) {
@@ -154,20 +275,20 @@ contract AccessAdmin is
         return _roleMembers[roleId].at(idx);
     }
 
-    function hasRole(address account, RoleId roleId) public view returns (bool) {
+    function isRoleMember(RoleId roleId, address account) public view returns (bool) {
         (bool isMember, ) = _authority.hasRole(
             RoleId.unwrap(roleId), 
             account);
         return isMember;
     }
 
-    function hasAdminRole(address account, RoleId roleId)
+    function isRoleAdmin(RoleId roleId, address account)
         public 
         virtual
         view 
         returns (bool)
     {
-        return hasRole(account, _roleInfo[roleId].adminRoleId);
+        return isRoleMember(_roleInfo[roleId].adminRoleId, account);
     }
 
     //--- view functions for targets ----------------------------------------//
@@ -219,245 +340,275 @@ contract AccessAdmin is
                 selector.toBytes4()));
     }
 
-    function isAccessManaged(address target) public view returns (bool) {
-        if (!_isContract(target)) {
-            return false;
-        }
-
-        (bool success, ) = target.staticcall(
-            abi.encodeWithSelector(
-                AccessManagedUpgradeable.authority.selector));
-
-        return success;
-    }
-
-    function canCall(address caller, address target, Selector selector) external virtual view returns (bool can) {
-        (can, ) = _authority.canCall(caller, target, selector.toBytes4());
-    }
-
-    function toRole(RoleId adminRoleId, RoleType roleType, uint32 maxMemberCount, string memory name) public view returns (RoleInfo memory) {
-        return RoleInfo({
-            name: StrLib.toStr(name),
-            adminRoleId: adminRoleId,
-            roleType: roleType,
-            maxMemberCount: maxMemberCount,
-            createdAt: TimestampLib.blockTimestamp()
-        });
-    }
-
-    function toFunction(bytes4 selector, string memory name) public view returns (FunctionInfo memory) {
-        return FunctionInfo({
-            name: StrLib.toStr(name),
-            selector: SelectorLib.toSelector(selector),
-            createdAt: TimestampLib.blockTimestamp()});
-    }
-
     function deployer() public view returns (address) {
         return _deployer;
     }
 
     //--- internal/private functions -------------------------------------------------//
 
-    function _authorizeTargetFunctions(
-        address target, 
-        RoleId roleId, 
-        FunctionInfo[] memory functions
-    )
-        internal
-    {
-        if (roleId == getAdminRole()) {
-            revert ErrorAuthorizeForAdminRoleInvalid(target);
-        }
-
-        bool addFunctions = true;
-        bytes4[] memory functionSelectors = _processFunctionSelectors(target, functions, addFunctions);
-
-        // apply authz via access manager
-        _grantRoleAccessToFunctions(target, roleId, functionSelectors);
-    }
-
-    function _unauthorizeTargetFunctions(
-        address target, 
-        FunctionInfo[] memory functions
-    )
-        internal
-    {
-        bool addFunctions = false;
-        bytes4[] memory functionSelectors = _processFunctionSelectors(target, functions, addFunctions);
-        _grantRoleAccessToFunctions(target, getAdminRole(), functionSelectors);
-    }
-
-    function _processFunctionSelectors(
-        address target,
-        FunctionInfo[] memory functions,
-        bool addFunctions
-    )
-        internal
-        returns (
-            bytes4[] memory functionSelectors
-        )
-    {
-        uint256 n = functions.length;
-        functionSelectors = new bytes4[](n);
-        FunctionInfo memory func;
-        Selector selector;
-
-        for (uint256 i = 0; i < n; i++) {
-            func = functions[i];
-            selector = func.selector;
-
-            // add function selector to target selector set if not in set
-            if (addFunctions) { SelectorSetLib.add(_targetFunctions[target], selector); } 
-            else { SelectorSetLib.remove(_targetFunctions[target], selector); }
-
-            // set function name
-            _functionInfo[target][selector] = func;
-
-            // add bytes4 selector to function selector array
-            functionSelectors[i] = selector.toBytes4();
-        }
-    }
-
-    function _initializeAuthority(
-        address authorityAddress
-    )
-        internal
-        virtual
-        onlyInitializing()
-        onlyDeployer()
-    {
-        if (authority() != address(0)) {
-            revert ErrorAuthorityAlreadySet();
+    function _linkToNftOwnable(address registerable) internal {
+        if (!getRegistry().isRegistered(registerable)) {
+            revert ErrorAccessAdminNotRegistered(registerable);
         }
 
-        _authority = AccessManagerCloneable(authorityAddress);
-        __AccessManaged_init(address(_authority));
+        _linkedNftId = getRegistry().getNftIdForAddress(registerable);
     }
 
-
     function _initializeAdminAndPublicRoles()
         internal
         virtual
         onlyInitializing()
     {
-        _createAdminAndPublicRoles();
-    }
-
-
-    /// @dev internal setup function that can be used in both constructor and initializer.
-    function _createAdminAndPublicRoles()
-        internal
-    {
-        RoleId adminRoleId = RoleIdLib.toRoleId(_authority.ADMIN_ROLE());
-        FunctionInfo[] memory functions;
-
         // setup admin role
         _createRoleUnchecked(
             ADMIN_ROLE(),
-            toRole({
+            AccessAdminLib.toRole({
                 adminRoleId: ADMIN_ROLE(),
                 roleType: RoleType.Contract,
                 maxMemberCount: 1,
-                name: ADMIN_ROLE_NAME}));
+                name: ADMIN_ROLE_NAME()}));
 
         // add this contract as admin role member
-        _roleMembers[adminRoleId].add(address(this));
+        _roleMembers[
+            RoleIdLib.toRoleId(_authority.ADMIN_ROLE())].add(address(this));
 
         // setup public role
         _createRoleUnchecked(
             PUBLIC_ROLE(),
-            toRole({
+            AccessAdminLib.toRole({
                 adminRoleId: ADMIN_ROLE(),
-                roleType: RoleType.Gif,
+                roleType: RoleType.Core,
                 maxMemberCount: type(uint32).max,
-                name: PUBLIC_ROLE_NAME}));
+                name: PUBLIC_ROLE_NAME()}));
     }
 
-    /// @dev check if target exists and reverts if it doesn't
-    function _checkTarget(address target)
+    // TODO cleanup
+    // function _createTargetWithRole(
+    //     address target,
+    //     string memory targetName,
+    //     RoleId targetRoleId
+    // )
+    //     internal
+    // {
+    //     _createTarget(target, targetName, true, false);
+    //     _grantRoleToAccount(targetRoleId, target);
+    // }
+
+    // TODO refactor / cleanup
+event LogAccessAdminDebugTarget(string name, address target, RoleId roleId, RoleId authorizedRoleId);
+
+    function _authorizeFunctions(IAuthorization authorization, Str target, RoleId roleId)
+        internal
+    {
+        RoleId authorizedRoleId = _toAuthorizedRoleId(authorization, roleId);
+        address getTargetAddress = getTargetForName(target);
+emit LogAccessAdminDebugTarget(target.toString(), getTargetAddress, roleId, authorizedRoleId);
+
+        _authorizeTargetFunctions(
+            getTargetForName(target),
+            authorizedRoleId,
+            authorization.getAuthorizedFunctions(
+                target, 
+                roleId),
+            true);
+    }
+
+    function _toAuthorizedRoleId(IAuthorization authorization, RoleId roleId)
         internal
+        returns (RoleId authorizedRoleId)
     {
-        if (_targetInfo[target].createdAt.eqz()) {
-            revert ErrorTargetUnknown(target);
+        // special case for service roles (service roles have predefined role ids)
+        if (roleId.isServiceRole()) {
+
+            // create service role if missing
+            if (!roleExists(roleId)) {
+                _createRole(
+                    roleId, 
+                    AccessAdminLib.toRole(
+                        ADMIN_ROLE(), 
+                        RoleType.Contract, 
+                        1, 
+                        authorization.getRoleName(roleId)));
+            }
+
+            return roleId;
         }
+
+        string memory roleName = authorization.getRoleInfo(roleId).name.toString();
+        return authorizedRoleId = getRoleForName(roleName);
     }
 
+    function _authorizeTargetFunctions(
+        address target, 
+        RoleId roleId, 
+        FunctionInfo[] memory functions,
+        bool addFunctions
+    )
+        internal
+    {
+        if (addFunctions && roleId == getAdminRole()) {
+            revert ErrorAccessAdminAuthorizeForAdminRoleInvalid(target);
+        }
+
+        // apply authz via access manager
+        _grantRoleAccessToFunctions(
+            target, 
+            roleId, 
+            functions,
+            addFunctions); // add functions
+    }
+
+    // function _unauthorizeTargetFunctions(
+    //     address target, 
+    //     FunctionInfo[] memory functions
+    // )
+    //     internal
+    // {
+    //     _grantRoleAccessToFunctions(
+    //         target, 
+    //         getAdminRole(), 
+    //         functions,
+    //         false);  // addFunctions
+    // }
+
+    // function _processFunctionSelectors(
+    //     address target,
+    //     FunctionInfo[] memory functions,
+    //     bool addFunctions
+    // )
+    //     internal
+    //     onlyExistingTarget(target)
+    //     returns (
+    //         bytes4[] memory functionSelectors,
+    //         string[] memory functionNames
+    //     )
+    // {
+    //     uint256 n = functions.length;
+    //     functionSelectors = new bytes4[](n);
+    //     functionNames = new string[](n);
+    //     FunctionInfo memory func;
+    //     Selector selector;
+
+    //     for (uint256 i = 0; i < n; i++) {
+    //         func = functions[i];
+    //         selector = func.selector;
+
+    //         // add function selector to target selector set if not in set
+    //         if (addFunctions) { SelectorSetLib.add(_targetFunctions[target], selector); } 
+    //         else { SelectorSetLib.remove(_targetFunctions[target], selector); }
+
+    //         // set function name
+    //         _functionInfo[target][selector] = func;
+
+    //         // add bytes4 selector to function selector array
+    //         functionSelectors[i] = selector.toBytes4();
+    //         functionNames[i] = func.name.toString();
+    //     }
+    // }
+
     /// @dev grant the specified role access to all functions in the provided selector list
     function _grantRoleAccessToFunctions(
         address target,
         RoleId roleId, 
-        bytes4[] memory functionSelectors
+        FunctionInfo[] memory functions,
+        bool addFunctions
     )
         internal
+        onlyExistingTarget(target)
+        onlyExistingRole(roleId, true, !addFunctions)
     {
         _authority.setTargetFunctionRole(
             target,
-            functionSelectors,
+            AccessAdminLib.getSelectors(functions),
             RoleId.unwrap(roleId));
 
-        // implizit logging: rely on OpenZeppelin log TargetFunctionRoleUpdated
+        // update function set and log function grantings
+        for (uint256 i = 0; i < functions.length; i++) {
+            _updateFunctionAccess(
+                target, 
+                roleId,
+                functions[i], 
+                addFunctions);
+        }
     }
 
+
+    function _updateFunctionAccess(
+        address target, 
+        RoleId roleId,
+        FunctionInfo memory func, 
+        bool addFunction
+    )
+        internal
+    {
+        // update functions info
+        Selector selector = func.selector;
+        _functionInfo[target][selector] = func;
+
+        // update function sets
+        if (addFunction) { SelectorSetLib.add(_targetFunctions[target], selector); } 
+        else { SelectorSetLib.remove(_targetFunctions[target], selector); }
+
+        // logging
+        emit LogAccessAdminFunctionGranted(
+            _adminName, 
+            target, 
+            string(abi.encodePacked(
+                func.name.toString(), 
+                "(): ",
+                _getRoleName(roleId))));
+    }
+
+
     /// @dev grant the specified role to the provided account
     function _grantRoleToAccount(RoleId roleId, address account)
         internal
+        onlyExistingRole(roleId, true, false)
     {
-        _checkRoleId(roleId);
-
         // check max role members will not be exceeded
         if (_roleMembers[roleId].length() >= _roleInfo[roleId].maxMemberCount) {
-            revert ErrorRoleMembersLimitReached(roleId, _roleInfo[roleId].maxMemberCount);
+            revert ErrorAccessAdminRoleMembersLimitReached(roleId, _roleInfo[roleId].maxMemberCount);
         }
 
         // check account is contract for contract role
-        // TODO implement
-        if (_roleInfo[roleId].roleType == RoleType.Contract) {
+        if (
+            _roleInfo[roleId].roleType == RoleType.Contract &&
+            !ContractLib.isContract(account) // will fail in account's constructor
+        ) {
+            revert ErrorAccessAdminRoleMemberNotContract(roleId, account);
         }
 
+        // effects
         _roleMembers[roleId].add(account);
         _authority.grantRole(
             RoleId.unwrap(roleId), 
             account, 
             0);
         
-        // indirect logging: rely on OpenZeppelin log RoleGranted
+        emit LogAccessAdminRoleGranted(_adminName, account, _getRoleName(roleId));
     }
 
     /// @dev revoke the specified role from the provided account
     function _revokeRoleFromAccount(RoleId roleId, address account)
         internal
+        onlyExistingRole(roleId, false, false)
     {
-        _checkRoleId(roleId);
 
         // check role removal is permitted
         if (_roleInfo[roleId].roleType == RoleType.Contract) {
-            revert ErrorRoleRemovalDisabled(roleId);
+            revert ErrorAccessAdminRoleMemberRemovalDisabled(roleId, account);
         }
 
+        // effects
         _roleMembers[roleId].remove(account);
         _authority.revokeRole(
             RoleId.unwrap(roleId), 
             account);
 
-        // indirect logging: rely on OpenZeppelin log RoleGranted
+        emit LogAccessAdminRoleRevoked(_adminName, account, _roleInfo[roleId].name.toString());
     }
 
 
-    function _checkRoleId(RoleId roleId)
-        internal
-    {
-        if (_roleInfo[roleId].createdAt.eqz()) {
-            revert ErrorRoleUnknown(roleId);
-        }
-
-        uint64 roleIdInt = RoleId.unwrap(roleId);
-        if (roleIdInt == _authority.ADMIN_ROLE()
-            || roleIdInt == _authority.PUBLIC_ROLE())
-        {
-            revert ErrorRoleIsLocked(roleId);
-        }
-    }
-
     /// @dev Creates a role based on the provided parameters.
     /// Checks that the provided role and role id and role name not already used.
     function _createRole(
@@ -466,32 +617,79 @@ contract AccessAdmin is
     )
         internal
     {
-        // check role does not yet exist
-        if(roleExists(roleId)) {
-            revert ErrorRoleAlreadyCreated(
-                roleId, 
-                _roleInfo[roleId].name.toString());
-        }
+        AccessAdminLib.checkRoleCreation(this, roleId, info);
+        _createRoleUnchecked(roleId, info);
+    }
 
-        // check admin role exists
-        if(!roleExists(info.adminRoleId)) {
-            revert ErrorRoleAdminNotExisting(info.adminRoleId);
-        }
 
-        // check role name is not empty
-        if(info.name.length() == 0) {
-            revert ErrorRoleNameEmpty(roleId);
+    /// @dev Activates or deactivates role.
+    /// The role activ property is indirectly controlled over the pausedAt timestamp.
+    function _setRoleActive(RoleId roleId, bool active)
+        internal
+    {
+        if (active) {
+            _roleInfo[roleId].pausedAt = TimestampLib.max();
+        } else {
+            _roleInfo[roleId].pausedAt = TimestampLib.blockTimestamp();
         }
+    }
 
-        // check role name is not used for another role
-        if(_roleForName[info.name].exists) {
-            revert ErrorRoleNameAlreadyExists(
-                roleId, 
-                info.name.toString(),
-                _roleForName[info.name].roleId);
-        }
 
-        _createRoleUnchecked(roleId, info);
+    function _createManagedTarget(
+        address target, 
+        string memory targetName, 
+        TargetType targetType
+    )
+        internal
+        returns (RoleId contractRoleId)
+    {
+        return _createTarget(target, targetName, targetType, true);
+    }
+
+
+    function _createUncheckedTarget(
+        address target, 
+        string memory targetName, 
+        TargetType targetType
+    )
+        internal
+    {
+        _createTarget(target, targetName, targetType, false);
+    }
+
+
+    function _createTarget(
+        address target, 
+        string memory targetName, 
+        TargetType targetType,
+        bool checkAuthority
+    )
+        private
+        returns (RoleId contractRoleId)
+    {
+        // checks
+        AccessAdminLib.checkTargetCreation(this, target, targetName, checkAuthority);
+
+        // effects
+        contractRoleId = _createTargetUnchecked(
+            target, 
+            targetName, 
+            targetType,
+            checkAuthority);
+
+        // deal with token handler, if applicable
+        (
+            address tokenHandler,
+            string memory tokenHandlerName
+        ) = AccessAdminLib.getTokenHandler(target, targetName, targetType);
+
+        if (tokenHandler != address(0)) {
+            _createTargetUnchecked(
+                tokenHandler, 
+                tokenHandlerName, 
+                targetType,
+                checkAuthority);
+        }
     }
 
 
@@ -503,6 +701,7 @@ contract AccessAdmin is
     {
         // create role info
         info.createdAt = TimestampLib.blockTimestamp();
+        info.pausedAt = TimestampLib.max();
         _roleInfo[roleId] = info;
 
         // create role name info
@@ -513,79 +712,164 @@ contract AccessAdmin is
         // add role to list of roles
         _roleIds.push(roleId);
 
-        emit LogRoleCreated(roleId, info.roleType, info.adminRoleId, info.name.toString());
+        emit LogAccessAdminRoleCreated(_adminName, roleId, info.roleType, info.adminRoleId, info.name.toString());
     }
 
-
-    function _createTarget(
+    /// @dev Creates a new target and a corresponding contract role.
+    /// The function assigns the role to the target and logs the creation.
+    function _createTargetUnchecked(
         address target, 
         string memory targetName, 
-        bool checkAuthority,
-        bool custom
+        TargetType targetType,
+        bool managed
     )
         internal
-        nonReentrant()
+        returns (RoleId targetRoleId)
     {
-        // check target does not yet exist
-        if(targetExists(target)) {
-            revert ErrorTargetAlreadyCreated(
-                target, 
-                _targetInfo[target].name.toString());
-        }
-
-        // check target name is not empty
-        Str name = StrLib.toStr(targetName);
-        if(name.length() == 0) {
-            revert ErrorTargetNameEmpty(target);
-        }
-
-        // check target name is not used for another target
-        if( _targetForName[name] != address(0)) {
-            revert ErrorTargetNameAlreadyExists(
-                target, 
-                targetName,
-                _targetForName[name]);
-        }
-
-        // check target is an access managed contract
-        if (!isAccessManaged(target)) {
-            revert ErrorTargetNotAccessManaged(target);
-        }
-
-        // check target shares authority with this contract
-        if (checkAuthority) {
-            address targetAuthority = AccessManagedUpgradeable(target).authority();
-            if (targetAuthority != authority()) {
-                revert ErrorTargetAuthorityMismatch(authority(), targetAuthority);
-            }
+        // create target role (if not existing)
+        string memory roleName;
+        (targetRoleId, roleName) = _getOrCreateTargetRoleIdAndName(target, targetName, targetType);
+
+        if (!roleExists(targetRoleId)) {
+            _createRole(
+                targetRoleId, 
+                AccessAdminLib.toRole(ADMIN_ROLE(), IAccess.RoleType.Contract, 1, roleName));
         }
 
         // create target info
+        Str name = StrLib.toStr(targetName);
         _targetInfo[target] = TargetInfo({
             name: name,
-            isCustom: custom,
+            targetType: targetType,
+            roleId: targetRoleId,
             createdAt: TimestampLib.blockTimestamp()
         });
 
         // create name to target mapping
         _targetForName[name] = target;
 
-        // add role to list of roles
+        // add target to list of targets
         _targets.push(target);
 
-        emit LogTargetCreated(target, targetName);
+        // grant contract role to target
+        _grantRoleToAccount(targetRoleId, target);
+
+        emit LogAccessAdminTargetCreated(_adminName, targetName, managed, target, targetRoleId);
     }
 
-    function _isContract(address target)
+
+    function _getOrCreateTargetRoleIdAndName(
+        address target,
+        string memory targetName,
+        TargetType targetType
+    )
         internal
-        view 
-        returns (bool)
+        returns (
+            RoleId roleId,
+            string memory roleName
+        )
     {
-        uint256 size;
-        assembly {
-            size := extcodesize(target)
+        // get roleId
+        if (targetType == TargetType.Service || targetType == TargetType.GenericService) {
+            roleId = AccessAdminLib.getServiceRoleId(target, targetType); 
+        } else {
+            roleId = AccessAdminLib.getTargetRoleId(target, targetType, _nextRoleId[targetType]);
+
+            // increment target type specific role id counter
+            _nextRoleId[targetType]++;
         }
-        return size > 0;
+
+        // create role name
+        roleName = AccessAdminLib.toRoleName(targetName);
+    }
+
+
+    function _setTargetLocked(address target, bool locked)
+        internal
+        onlyExistingTarget(target)
+    {
+        _authority.setTargetClosed(target, locked);
     }
-    
+
+
+    function _getRoleName(RoleId roleId) internal view returns (string memory) {
+        if (roleExists(roleId)) {
+            return _roleInfo[roleId].name.toString();
+        }
+        return "<unknown-role>";
+    }
+
+
+    function _checkAuthorization( 
+        address authorization,
+        ObjectType expectedDomain, 
+        VersionPart expectedRelease,
+        bool checkAlreadyInitialized
+    )
+        internal
+        view
+    {
+        AccessAdminLib.checkAuthorization(
+            address(_authorization), 
+            authorization, 
+            expectedDomain, 
+            expectedRelease, 
+            checkAlreadyInitialized);
+    }
+
+
+    function _checkRoleExists( 
+        RoleId roleId, 
+        bool onlyActiveRole
+    )
+        internal
+        view
+    {
+        if (!roleExists(roleId)) {
+            revert ErrorAccessAdminRoleUnknown(roleId);
+        }
+
+        uint64 roleIdInt = RoleId.unwrap(roleId);
+        if (roleIdInt == _authority.ADMIN_ROLE()) {
+            revert ErrorAccessAdminRoleIsLocked(roleId);
+        }
+
+        // check if role is disabled
+        if (onlyActiveRole && _roleInfo[roleId].pausedAt <= TimestampLib.blockTimestamp()) {
+            revert ErrorAccessAdminRoleIsPaused(roleId);
+        }
+    }
+
+
+
+    /// @dev check if target exists and reverts if it doesn't
+    function _checkTargetExists(
+        address target
+    )
+        internal
+        view
+    {
+        // check not yet created
+        if (!targetExists(target)) {
+            revert ErrorAccessAdminTargetNotCreated(target);
+        }
+    }
+
+    // TODO cleanup
+    // function _checkIsRegistered( 
+    //     address registry,
+    //     address target,
+    //     ObjectType expectedType
+    // )
+    //     internal
+    //     view
+    // {
+    //     AccessAdminLib.checkIsRegistered(registry, target, expectedType);
+    // }
+
+    // function _checkRegistry(address registry) internal view {
+    //     if (!ContractLib.isRegistry(registry)) {
+    //         revert ErrorAccessAdminNotRegistry(registry);
+    //     }
+    // }
 }