@etherisc/gif-next 0.0.2-f1b01e0-214 → 0.0.2-f1e6957-384

package/contracts/authorization/Authorization.sol

@@ -4,84 +4,65 @@ pragma solidity ^0.8.20;
 import {IAccess} from "./IAccess.sol";
 import {IAuthorization} from "./IAuthorization.sol";
 
-import {InitializableERC165} from "../shared/InitializableERC165.sol";
-import {ObjectType, ObjectTypeLib} from "../type/ObjectType.sol";
-import {RoleId, RoleIdLib, ADMIN_ROLE} from "../type/RoleId.sol";
-import {SelectorLib} from "../type/Selector.sol";
+import {AccessAdminLib} from "./AccessAdminLib.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {ServiceAuthorization} from "../authorization/ServiceAuthorization.sol";
 import {Str, StrLib} from "../type/String.sol";
-import {TimestampLib} from "../type/Timestamp.sol";
-import {VersionPart, VersionPartLib} from "../type/Version.sol";
+
 
 contract Authorization is
-    InitializableERC165,
+    ServiceAuthorization,
     IAuthorization
 {
-    uint256 public constant GIF_RELEASE = 3;
 
-    string public constant ROLE_NAME_SUFFIX = "Role";
-    string public constant SERVICE_ROLE_NAME_SUFFIX = "ServiceRole";
+    // MUST match with AccessAdminLib.COMPONENT_ROLE_MIN
+    uint64 public constant COMPONENT_ROLE_MIN = 110000;
+    uint64 public constant INSTANCE_ROLE_MIN = 100000;
 
     uint64 internal _nextGifContractRoleId;
-    ObjectType[] internal _serviceDomains;
-    mapping(ObjectType domain => Str target) internal _serviceTarget;
-
-    string internal _mainTargetName = "Component";
-    string internal _tokenHandlerName = "ComponentTH";
+    uint64 internal _nextInstanceContractRoleId;
 
-    ObjectType internal _domain;
-    Str internal _mainTarget;
+    string internal _tokenHandlerName = "ComponentTh";
     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, 
-        bool isComponent,
+        ObjectType domain,
+        uint8 release,
+        string memory commitHash,
+        IAccess.TargetType targetType,
         bool includeTokenHandler
     )
+        ServiceAuthorization(mainTargetName, domain, release, commitHash)
     {
-        // checks
-        if (bytes(mainTargetName).length == 0) {
-            revert ErrorAuthorizationMainTargetNameEmpty();
-        }
-
-        if (targetDomain == ObjectTypeLib.zero()) {
-            revert ErrorAuthorizationTargetDomainZero();
-        }
-
-        // effects
-        _initializeERC165();
-
-        _domain = targetDomain;
-        _mainTargetName = mainTargetName;
-        _mainTarget = StrLib.toStr(mainTargetName);
-        _nextGifContractRoleId = 10;
-
-        if (isComponent) {
-            if (targetDomain.eqz()) {
+        // IMPORTANT must match with AccessAdminLib.CORE_ROLE_MIN
+        _nextGifContractRoleId = 100;
+        _nextInstanceContractRoleId = INSTANCE_ROLE_MIN;
+
+        // setup main target
+        // special case: core targets
+        if (targetType == IAccess.TargetType.Core) {
+            _addGifTarget(_mainTargetName);
+        // special case instances
+        } else if (targetType == IAccess.TargetType.Instance) {
+            _addInstanceTarget(_mainTargetName);
+        // all other target types
+        } else {
+            if (domain.eqz()) {
                 revert ErrorAuthorizationTargetDomainZero();
             }
 
-            RoleId mainRoleId = RoleIdLib.toComponentRoleId(targetDomain, 0);
-            string memory mainRolName = _toTargetRoleName(_mainTargetName);
+            RoleId mainRoleId = RoleIdLib.toRoleId(COMPONENT_ROLE_MIN);
+            string memory mainRoleName = _toTargetRoleName(_mainTargetName);
 
             _addTargetWithRole(
                 _mainTargetName, 
                 mainRoleId,
-                mainRolName);
-        } else {
-            _addGifContractTarget(_mainTargetName);
+                mainRoleName);
         }
+
         // setup use case specific parts
         _setupServiceTargets();
         _setupRoles(); // not including main target role
@@ -90,7 +71,7 @@ contract Authorization is
 
         // setup component token handler 
         if (includeTokenHandler) {
-            _tokenHandlerName = string(abi.encodePacked(mainTargetName, "TH"));
+            _tokenHandlerName = string(abi.encodePacked(mainTargetName, "Th"));
             _tokenHandlerTarget = StrLib.toStr(_tokenHandlerName);
             _addTarget(_tokenHandlerName);
             _setupTokenHandlerAuthorizations();
@@ -99,47 +80,6 @@ contract Authorization is
         _registerInterfaceNotInitializing(type(IAuthorization).interfaceId);
     }
 
-    function getDomain() external view returns(ObjectType targetDomain) {
-        return _domain;
-    }
-
-    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;
@@ -149,7 +89,7 @@ contract Authorization is
         return _tokenHandlerTarget;
     }
 
-    function getTarget(string memory targetName) public view returns(Str target) {
+    function getTarget(string memory targetName) public pure returns(Str target) {
         return StrLib.toStr(targetName);
     }
 
@@ -161,44 +101,45 @@ contract Authorization is
         return target == _mainTarget || _targetExists[target];
     }
 
-    function getTargetRole(Str target) public 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.
+    // solhint-disable-next-line no-empty-blocks
     function _setupServiceTargets() internal virtual { }
 
     /// @dev Sets up the relevant (non-service) targets for the component.
     /// Overwrite this function for use case specific authorizations.
+    // solhint-disable-next-line no-empty-blocks
     function _setupTargets() internal virtual { }
 
     /// @dev Sets up the relevant roles for the component.
     /// Overwrite this function for use case specific authorizations.
+    // solhint-disable-next-line no-empty-blocks
     function _setupRoles() internal virtual {}
 
     /// @dev Sets up the relevant component's token handler authorizations.
     /// Overwrite this function for use case specific authorizations.
+    // solhint-disable-next-line no-empty-blocks
     function _setupTokenHandlerAuthorizations() internal virtual {}
 
     /// @dev Sets up the relevant target authorizations for the component.
     /// Overwrite this function for use case specific authorizations.
+    // solhint-disable-next-line no-empty-blocks
     function _setupTargetAuthorizations() internal virtual {}
 
-    function _addGifContractTarget(string memory contractName) internal {
 
+    /// @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,
+            AccessAdminLib.roleInfo(
+                adminRoleId,
+                TargetType.Custom,
+                maxMemberCount,
+                name));
+    }
+
+    /// @dev Add a gif target with its corresponding contract role
+    function _addGifTarget(string memory contractName) internal {
         RoleId contractRoleId = RoleIdLib.toRoleId(_nextGifContractRoleId++);
         string memory contractRoleName = string(
             abi.encodePacked(
@@ -211,155 +152,39 @@ contract Authorization is
             contractRoleName);
     }
 
-    /// @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());
-
-        _serviceTarget[serviceDomain] = StrLib.toStr(serviceTargetName);
-
-        RoleId serviceRoleId = getServiceRole(serviceDomain);
-        string memory serviceRoleName = ObjectTypeLib.toVersionedName(
-                ObjectTypeLib.toName(serviceDomain), 
-                "ServiceRole", 
-                getRelease());
+    /// @dev Add an instance target with its corresponding contract role
+    function _addInstanceTarget(string memory contractName) internal {
+        RoleId contractRoleId = RoleIdLib.toRoleId(_nextInstanceContractRoleId++);
+        string memory contractRoleName = _toTargetRoleName(contractName);
 
         _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()));
-    }
-
-
-    /// @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;
-        }
+            contractName, 
+            contractRoleId,
+            contractRoleName);
     }
 
-
     /// @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
+    /// @dev Role id for targets registry, staking and instance
     function _toTargetRoleId(ObjectType targetDomain) 
         internal
         pure
         returns (RoleId targetRoleId)
     {
-        return RoleIdLib.roleForType(targetDomain);
+        return RoleIdLib.toRoleId(100 * targetDomain.toInt());
     }
 
 
+    /// @dev Returns the role name for the specified target name
     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

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.20;
 
+import {Blocknumber} from "../type/Blocknumber.sol";
 import {RoleId} from "../type/RoleId.sol";
 import {Selector} from "../type/Selector.sol";
 import {Str} from "../type/String.sol";
@@ -8,30 +9,37 @@ 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
+    enum TargetType {
+        Undefined, // no target must have this type
+        Core, // GIF core contracts
+        GenericService, // release independent service contracts
+        Service, // service contracts
+        Instance, // instance contracts
+        Component, // instance contracts
+        Contract, // normal contracts
+        Custom // use case specific rules for contracts or normal accounts
     }
 
     struct RoleInfo {
         // slot 0
-        RoleId adminRoleId; 
-        RoleType roleType; 
-        uint32 maxMemberCount; 
-        Timestamp createdAt; 
-        Timestamp pausedAt; 
+        RoleId adminRoleId;  // 64
+        TargetType targetType; // ?
+        uint32 maxMemberCount; // 32
+        Timestamp createdAt; // 40
+        Timestamp pausedAt; // 40
+        Blocknumber lastUpdateIn; // 40
         // slot 1
-        Str name;
+        Str name; // 256
     }
 
+
+    // TODO recalc slot allocation
     struct TargetInfo {
-        // slot 0
         Str name;
-        // slot 1
-        bool isCustom;
+        TargetType targetType;
+        RoleId roleId;
         Timestamp createdAt;
+        Blocknumber lastUpdateIn;
     }
 
     struct FunctionInfo {
@@ -40,6 +48,7 @@ interface IAccess {
         // slot 1
         Selector selector; // function selector
         Timestamp createdAt;
+        Blocknumber lastUpdateIn;
     }
 
     struct RoleNameInfo {

package/contracts/authorization/IAccessAdmin.sol

@@ -8,13 +8,14 @@ import {IAuthorization} from "./IAuthorization.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
 import {IRelease} from "../registry/IRelease.sol";
 
+import {Blocknumber} from "../type/Blocknumber.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType} from "../type/ObjectType.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";
 
+/// @dev Base interface for registry admin, release admin, and instance admin 
 interface IAccessAdmin is 
     IAccessManaged,
     IAccess,
@@ -23,12 +24,14 @@ interface IAccessAdmin is
 {
 
     // roles, targets and functions
-    event LogAccessAdminRoleCreated(string admin, RoleId roleId, RoleType roleType, RoleId roleAdminId, string name);
-    event LogAccessAdminTargetCreated(string admin, address target, string name);
+    event LogAccessAdminRoleCreated(string admin, RoleId roleId, TargetType targetType, RoleId roleAdminId, string name);
+    event LogAccessAdminTargetCreated(string admin, string name, bool managed, address target, RoleId roleId);
 
+    event LogAccessAdminRoleActivatedSet(string admin, RoleId roleId, bool active, Blocknumber lastUpdateIn);
     event LogAccessAdminRoleGranted(string admin, address account, string roleName);
     event LogAccessAdminRoleRevoked(string admin, address account, string roleName);
-    event LogAccessAdminFunctionGranted(string admin, address target, string func);
+    event LogAccessAdminTargetLockedSet(string admin, address target, bool locked, Blocknumber lastUpdateIn);
+    event LogAccessAdminFunctionGranted(string admin, address target, string func, Blocknumber lastUpdateIn);
 
     // only deployer modifier
     error ErrorAccessAdminNotDeployer();
@@ -39,6 +42,11 @@ interface IAccessAdmin is
     // only role owner modifier
     error ErrorAccessAdminNotRoleOwner(RoleId roleId, address account);
 
+    // role management
+    error ErrorAccessAdminInvalidUseOfAdminRole();
+    error ErrorAccessAdminInvalidUseOfPublicRole();
+    error ErrorAccessAdminRoleNotCustom(RoleId roleId);
+
     // initialization
     error ErrorAccessAdminNotRegistry(address registry);
     error ErrorAccessAdminAuthorityNotContract(address authority);
@@ -46,6 +54,8 @@ interface IAccessAdmin is
     error ErrorAccessAdminAccessManagerEmptyName();
 
     // check target
+    error ErrorAccessAdminInvalidTargetType(address target, TargetType targetType);
+    error ErrorAccessAdminInvalidServiceType(address target, TargetType serviceTargetType);
     error ErrorAccessAdminTargetNotCreated(address target);
     error ErrorAccessAdminTargetNotRegistered(address target);
     error ErrorAccessAdminTargetTypeMismatch(address target, ObjectType expectedType, ObjectType actualType);
@@ -53,6 +63,7 @@ interface IAccessAdmin is
     // check authorization
     error ErrorAccessAdminAlreadyInitialized(address authorization);
     error ErrorAccessAdminNotAuthorization(address authorization);
+    error ErrorAccessAdminNotServiceAuthorization(address serviceAuthorization);
     error ErrorAccessAdminDomainMismatch(address authorization, ObjectType expectedDomain, ObjectType actualDomain);
     error ErrorAccessAdminReleaseMismatch(address authorization, VersionPart expectedRelease, VersionPart actualRelease);
 
@@ -88,71 +99,34 @@ interface IAccessAdmin is
     error ErrorAccessAdminTargetAlreadyLocked(address target, bool isLocked);
 
     // authorize target functions
+    error ErrorAccessAdminNotComponentOrCustomTarget(address target);
     error ErrorAccessAdminAuthorizeForAdminRoleInvalid(address target);
 
+    // toFunction
+    error ErrorAccessAdminSelectorZero();
+    error ErrorAccessAdminFunctionNameEmpty();
+
     // check target
     error ErrorAccessAdminTargetUnknown(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 getAuthorization() external view returns (IAuthorization authorization);
     function getLinkedNftId() external view returns (NftId linkedNftId);
-    function getLinkedOwner() external view returns (address linkedOwner);
 
     function isLocked() external view returns (bool locked);
 
     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 getRoleForName(string memory name) external view returns (RoleId roleId);
+    function getRoleForName(string memory name) external view returns (RoleId roleId, bool exists);
     function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory roleInfo);
+    function isRoleActive(RoleId roleId) external view returns (bool isActive);
+    function isRoleCustom(RoleId roleId) external view returns (bool isCustom);
 
-    function hasRole(address account, RoleId roleId) external view returns (bool);
-    function hasAdminRole(address account, RoleId roleId) external view returns (bool);
+    function isRoleMember(RoleId roleId, address account) external view returns (bool);
+    function isRoleAdmin(RoleId roleId, address account) external view returns (bool);
     function roleMembers(RoleId roleId) external view returns (uint256 numberOfMembers);
     function getRoleMember(RoleId roleId, uint256 idx) external view returns (address account);
 
@@ -165,6 +139,4 @@ interface IAccessAdmin is
 
     function authorizedFunctions(address target) external view returns (uint256 numberOfFunctions);
     function getAuthorizedFunction(address target, uint256 idx) external view returns (FunctionInfo memory func, RoleId roleId);
-
-    function deployer() external view returns (address);
 }