@etherisc/gif-next 0.0.2-952752e-374 → 0.0.2-957bd35-589

package/contracts/authorization/AccessManagerCloneable.sol

@@ -2,12 +2,11 @@
 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";
+import {VersionPart} from "../type/Version.sol";
 
 
 /// @dev An AccessManager based on OpenZeppelin that is cloneable and has a central lock property.
@@ -28,6 +27,7 @@ contract AccessManagerCloneable is
     VersionPart private _release;
     bool private _isLocked;
 
+
     modifier onlyAdminRole() {
         (bool isMember, ) = hasRole(ADMIN_ROLE, msg.sender);
         if(!isMember) {
@@ -36,12 +36,14 @@ contract AccessManagerCloneable is
         _;
     }
 
+
     function initialize(address admin)
-        external
+        public
         initializer()
     {
+        __ERC165_init();
         __AccessManager_init(admin);
-        _initializeERC165();
+
         _registerInterface(type(IAccessManager).interfaceId);
     }
 
@@ -56,21 +58,8 @@ contract AccessManagerCloneable is
         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);
+        _checkAndSetRegistry(registry);
+        _checkAndSetRelease(release);
     }
 
     /// @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.
@@ -89,12 +78,12 @@ contract AccessManagerCloneable is
             uint32 delay
         ) 
     {
-        (immediate, delay) = super.canCall(caller, target, selector);
-
         // locking of all contracts under control of this access manager
-        if (isLocked()) {
+        if (_isLocked) {
             revert ErrorAccessManagerTargetAdminLocked(target);
         }
+
+        (immediate, delay) = super.canCall(caller, target, selector);
     }
 
 
@@ -126,11 +115,18 @@ contract AccessManagerCloneable is
     }
 
 
-    function _completeSetup(
-        address registry,
-        VersionPart release,
-        bool verifyRelease
-    )
+    function _checkAndSetRelease(VersionPart release)
+        internal
+    {
+        if (!release.isValidRelease()) {
+            revert ErrorAccessManagerInvalidRelease(release);
+        }
+
+        _release = release;
+    }
+
+
+    function _checkAndSetRegistry(address registry)
         internal
     {
         // checks
@@ -138,12 +134,7 @@ contract AccessManagerCloneable is
             revert ErrorAccessManagerRegistryAlreadySet(address(getRegistry()) );
         }
 
-        if (verifyRelease && !release.isValidRelease()) {
-            revert ErrorAccessManagerInvalidRelease(release);
-        }
-
         // effects
         __RegistryLinked_init(registry);
-        _release = release;
     }
 }

package/contracts/authorization/Authorization.sol

@@ -3,287 +3,188 @@ pragma solidity ^0.8.20;
 
 import {IAccess} from "./IAccess.sol";
 import {IAuthorization} from "./IAuthorization.sol";
-import {ObjectType, ObjectTypeLib} 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";
-    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;
+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";
 
 
-    constructor(string memory mainTargetName) {
-        _mainTargetName = mainTargetName;
+contract Authorization is
+    ServiceAuthorization,
+    IAuthorization
+{
 
+    // MUST match with AccessAdminLib.COMPONENT_ROLE_MIN
+    uint64 public constant COMPONENT_ROLE_MIN = 110000;
+    uint64 public constant INSTANCE_ROLE_MIN = 100000;
+
+    uint64 internal _nextGifContractRoleId;
+    uint64 internal _nextInstanceContractRoleId;
+
+    string internal _tokenHandlerName = "ComponentTh";
+    Str internal _tokenHandlerTarget;
+
+
+    constructor(
+        string memory mainTargetName, 
+        ObjectType domain,
+        uint8 release,
+        string memory commitHash,
+        IAccess.TargetType targetType,
+        bool includeTokenHandler
+    )
+        ServiceAuthorization(mainTargetName, domain, release, commitHash)
+    {
+        // 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.toRoleId(COMPONENT_ROLE_MIN);
+            string memory mainRoleName = _toTargetRoleName(_mainTargetName);
+
+            _addTargetWithRole(
+                _mainTargetName, 
+                mainRoleId,
+                mainRoleName);
+        }
+
+        // setup use case specific parts
         _setupServiceTargets();
-        _setupRoles();
-        _setupTargets();
-        _setupTargetAuthorizations();
+        _setupRoles(); // not including main target role
+        _setupTargets(); // not including main target (and token handler target)
+        _setupTargetAuthorizations(); // not including token handler target
+
+        // setup component token handler 
+        if (includeTokenHandler) {
+            _tokenHandlerName = string(abi.encodePacked(mainTargetName, "Th"));
+            _tokenHandlerTarget = StrLib.toStr(_tokenHandlerName);
+            _addTarget(_tokenHandlerName);
+            _setupTokenHandlerAuthorizations();
+        }
+
+        _registerInterfaceNotInitializing(type(IAuthorization).interfaceId);
     }
 
-     function getServiceDomains() external view returns(ObjectType[] memory serviceDomains) {
-          return _serviceDomains;
-     }
 
-     function getServiceRole(ObjectType serviceDomain) public virtual pure returns (RoleId serviceRoleId) {
-          return RoleIdLib.roleForTypeAndVersion(
-               serviceDomain, 
-               getRelease());
-     }
+    function getTokenHandlerName() public view returns(string memory) {
+        return _tokenHandlerName;
+    }
 
-     function getServiceTarget(ObjectType serviceDomain) external view returns(Str serviceTarget) {
-          return _serviceTarget[serviceDomain];
-     }
+    function getTokenHandlerTarget() public view returns(Str) {
+        return _tokenHandlerTarget;
+    }
 
-     function getRoles() external view returns(RoleId[] memory roles) {
-          return _roles;
-     }
+    function getTarget(string memory targetName) public pure returns(Str target) {
+        return StrLib.toStr(targetName);
+    }
 
-     function roleExists(RoleId roleId) public view returns(bool exists) {
-          return _roleInfo[roleId].roleType != RoleType.Undefined;
-     }
+    function getTargets() external view returns(Str[] memory targets) {
+        return _targets;
+    }
 
-     function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory info) {
-          return _roleInfo[roleId];
-     }
+    function targetExists(Str target) external view returns(bool exists) {
+        return target == _mainTarget || _targetExists[target];
+    }
 
-     function getTargetName() public virtual view returns (string memory name) {
-          return _mainTargetName;
-     }
+    /// @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 {}
+
+
+    /// @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));
+    }
 
-     function getMainTarget() public view returns(Str) {
-          return getTarget(_mainTargetName);
-     }
+    /// @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(
+                contractName,
+                ROLE_NAME_SUFFIX));
+
+        _addTargetWithRole(
+            contractName,
+            contractRoleId,
+            contractRoleName);
+    }
 
-     function getTarget(string memory targetName) public view returns(Str target) {
-          return StrLib.toStr(targetName);
-     }
+    /// @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);
 
-     function getTargets() external view returns(Str[] memory targets) {
-          return _targets;
-     }
+        _addTargetWithRole(
+            contractName, 
+            contractRoleId,
+            contractRoleName);
+    }
 
-     function targetExists(Str target) external view returns(bool exists) {
-          return _targetExists[target];
-     }
+    /// @dev Use this method to to add an authorized target.
+    function _addTarget(string memory name) internal {
+        _addTargetWithRole(name, RoleIdLib.zero(), "");
+    }
 
-     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];
-     }
+    /// @dev Role id for targets registry, staking and instance
+    function _toTargetRoleId(ObjectType targetDomain) 
+        internal
+        pure
+        returns (RoleId targetRoleId)
+    {
+        return RoleIdLib.toRoleId(100 * targetDomain.toInt());
+    }
 
-     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 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 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()});
-     }
 }
 

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,40 +9,56 @@ 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 {
-        RoleId adminRoleId;
-        RoleType roleType;
-        uint32 maxMemberCount;
-        Str name;
-        Timestamp createdAt;
-        Timestamp pausedAt;
+        // slot 0
+        RoleId adminRoleId;  // 64
+        TargetType targetType; // ?
+        uint32 maxMemberCount; // 32
+        Timestamp createdAt; // 40
+        Timestamp pausedAt; // 40
+        Blocknumber lastUpdateIn; // 40
+        // slot 1
+        Str name; // 256
     }
 
+
+    // TODO recalc slot allocation
     struct TargetInfo {
         Str name;
-        bool isCustom;
+        TargetType targetType;
+        RoleId roleId;
         Timestamp createdAt;
+        Blocknumber lastUpdateIn;
     }
 
     struct FunctionInfo {
+        // slot 0
         Str name; // function name
+        // slot 1
         Selector selector; // function selector
         Timestamp createdAt;
+        Blocknumber lastUpdateIn;
     }
 
     struct RoleNameInfo {
+        // slot 0
         RoleId roleId;
         bool exists;
     }
 
     struct TargeNameInfo {
+        // slot 0
         address target;
         bool exists;
     }