@etherisc/gif-next 0.0.2-98e9f45-792 → 0.0.2-998ff1b-888

package/contracts/registry/RegistryAdmin.sol

@@ -7,11 +7,10 @@ import {IRegistry} from "./IRegistry.sol";
 import {IService} from "../shared/IService.sol";
 import {IServiceAuthorization} from "../authorization/IServiceAuthorization.sol";
 import {IStaking} from "../staking/IStaking.sol";
-import {ObjectType, ObjectTypeLib, ALL, POOL, RELEASE} from "../type/ObjectType.sol";
+import {ObjectType, ObjectTypeLib, ALL, REGISTRY, STAKING, POOL, RELEASE} from "../type/ObjectType.sol";
 import {ReleaseRegistry} from "./ReleaseRegistry.sol";
 import {RoleId, RoleIdLib, ADMIN_ROLE, GIF_MANAGER_ROLE, GIF_ADMIN_ROLE, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {StakingStore} from "../staking/StakingStore.sol";
-import {STAKING} from "../type/ObjectType.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {TokenRegistry} from "./TokenRegistry.sol";
 import {VersionPart} from "../type/Version.sol";
@@ -27,37 +26,33 @@ import {VersionPart} from "../type/Version.sol";
         - MUST have 1 member at any time
         - granted/revoked ONLY in transferAdminRole() -> consider lock out situations!!!
         - responsible for creation and activation of releases
-
-    createServiceTarget(type, release)
-    createServiceRole(type,release)
-    getServiceRole(type, release)
 */
 contract RegistryAdmin is
     AccessAdmin
 {
-    error ErrorRegistryAdminIsAlreadySetUp();
-
     string public constant GIF_ADMIN_ROLE_NAME = "GifAdminRole";
     string public constant GIF_MANAGER_ROLE_NAME = "GifManagerRole";
     string public constant POOL_SERVICE_ROLE_NAME = "PoolServiceRole";
     string public constant RELEASE_REGISTRY_ROLE_NAME = "ReleaseRegistryRole";
+    string public constant REGISTRY_SERVICE_ROLE_NAME = "RegistryServiceRole";
     string public constant STAKING_SERVICE_ROLE_NAME = "StakingServiceRole";
     string public constant STAKING_ROLE_NAME = "StakingRole";
 
+    string public constant REGISTRY_TARGET_NAME = "Registry";
     string public constant RELEASE_REGISTRY_TARGET_NAME = "ReleaseRegistry";
     string public constant TOKEN_REGISTRY_TARGET_NAME = "TokenRegistry";
     string public constant STAKING_TARGET_NAME = "Staking";
     string public constant STAKING_STORE_TARGET_NAME = "StakingStore";
 
     uint8 public constant MAX_NUM_RELEASES = 99;
-
+    // TODO consider deleting this
     mapping(address service => VersionPart majorVersion) private _ServiceRelease;
 
+    address internal _registry;
     address private _releaseRegistry;
     address private _tokenRegistry;
     address private _staking;
     address private _stakingStore;
-    bool private _setupCompleted;
 
     constructor() AccessAdmin() { }
 
@@ -67,11 +62,10 @@ contract RegistryAdmin is
         address gifManager
     )
         external
+        initializer
         onlyDeployer()
     {
-        if (_setupCompleted) { revert ErrorRegistryAdminIsAlreadySetUp(); } 
-        else { _setupCompleted = true; }
-
+        _registry = address(registry);
         _releaseRegistry = registry.getReleaseRegistryAddress();
         _tokenRegistry = registry.getTokenRegistryAddress();
         _staking = registry.getStakingAddress();
@@ -85,6 +79,7 @@ contract RegistryAdmin is
         _setupGifManagerRole(gifManager);
 
         _setupReleaseRegistry();
+        _setupRegistry();
         _setupStaking();
     }
 
@@ -94,15 +89,46 @@ contract RegistryAdmin is
     /// Permissioned function: Access is restricted to release manager.
     function authorizeService(
         IServiceAuthorization serviceAuthorization,
-        IService service
+        IService service,
+        ObjectType serviceDomain,
+        VersionPart releaseVersion
     )
         external
         restricted()
     {
-        _createServiceTargetAndRole(service);
-        _authorizeServiceFunctions(serviceAuthorization, service);
+        _createServiceTargetAndRole(service, serviceDomain, releaseVersion);
+        _authorizeServiceFunctions(serviceAuthorization, service, serviceDomain, releaseVersion);
+    }
+
+    function grantServiceRole(
+        IService service,
+        ObjectType domain, 
+        VersionPart version
+    )
+        external
+        restricted()
+    {
+        _grantRoleToAccount( 
+            RoleIdLib.roleForTypeAndVersion(
+                domain, 
+                version),
+            address(service)); 
     }
 
+    function revokeServiceRole(
+        IService service,
+        ObjectType domain, 
+        VersionPart version
+    )
+        external
+        restricted()
+    {
+        _revokeRoleFromAccount(
+            RoleIdLib.roleForTypeAndVersion(
+                domain, 
+                version), 
+            address(service));
+    }
 
     function grantServiceRoleForAllVersions(IService service, ObjectType domain)
         external
@@ -113,14 +139,44 @@ contract RegistryAdmin is
             address(service)); 
     }
 
+    function revokeServiceRoleForAllVersions(IService service, ObjectType domain)
+        external
+        restricted()
+    {
+        _revokeRoleFromAccount(
+            RoleIdLib.roleForTypeAndAllVersions(domain), 
+            address(service));
+    }
 
-    function _createServiceTargetAndRole(IService service)
+    /*function transferAdmin(address to)
+        external
+        restricted // only with GIF_ADMIN_ROLE or nft owner
+    {
+        _accessManager.revoke(GIF_ADMIN_ROLE, );
+        _accesssManager.grant(GIF_ADMIN_ROLE, to, 0);
+    }*/
+
+    //--- view functions ----------------------------------------------------//
+
+    function getGifAdminRole() external view returns (RoleId) {
+        return GIF_ADMIN_ROLE();
+    }
+
+    function getGifManagerRole() external view returns (RoleId) {
+        return GIF_MANAGER_ROLE();
+    }
+
+    //--- private functions -------------------------------------------------//
+
+    function _createServiceTargetAndRole(
+        IService service, 
+        ObjectType serviceDomain, 
+        VersionPart releaseVersion
+    )
         private
     {
-        ObjectType serviceDomain = service.getDomain();
         string memory baseName = ObjectTypeLib.toName(serviceDomain);
-        VersionPart version = service.getVersion().toMajorPart();
-        uint256 versionInt = version.toInt();
+        uint256 versionInt = releaseVersion.toInt();
 
         // create service target
         string memory serviceTargetName = ObjectTypeLib.toVersionedName(
@@ -135,7 +191,7 @@ contract RegistryAdmin is
         // create service role
         RoleId serviceRoleId = RoleIdLib.roleForTypeAndVersion(
             serviceDomain, 
-            version);
+            releaseVersion);
 
         _createRole(
             serviceRoleId, 
@@ -156,15 +212,15 @@ contract RegistryAdmin is
 
     function _authorizeServiceFunctions(
         IServiceAuthorization serviceAuthorization,
-        IService service
+        IService service,
+        ObjectType serviceDomain, 
+        VersionPart releaseVersion
     )
         private
     {
-        ObjectType serviceDomain = service.getDomain();
         ObjectType authorizedDomain;
         RoleId authorizedRoleId;
 
-        VersionPart release = service.getVersion().toMajorPart();
         ObjectType[] memory authorizedDomains = serviceAuthorization.getAuthorizedDomains(serviceDomain);
 
         for (uint256 i = 0; i < authorizedDomains.length; i++) {
@@ -176,7 +232,7 @@ contract RegistryAdmin is
             } else {
                 authorizedRoleId = RoleIdLib.roleForTypeAndVersion(
                 authorizedDomain, 
-                release);
+                releaseVersion);
             }
 
             // get authorized functions for authorized domain
@@ -191,27 +247,12 @@ contract RegistryAdmin is
         }
     }
 
-    /*function transferAdmin(address to)
-        external
-        restricted // only with GIF_ADMIN_ROLE or nft owner
-    {
-        _accessManager.revoke(GIF_ADMIN_ROLE, );
-        _accesssManager.grant(GIF_ADMIN_ROLE, to, 0);
-    }*/
+    //--- private initialization functions -------------------------------------------//
 
-    //--- view functions ----------------------------------------------------//
-
-    function getGifAdminRole() external view returns (RoleId) {
-        return GIF_ADMIN_ROLE();
-    }
-
-    function getGifManagerRole() external view returns (RoleId) {
-        return GIF_MANAGER_ROLE();
-    }
-
-    //--- private functions -------------------------------------------------//
-
-    function _setupGifAdminRole(address gifAdmin) private {
+    function _setupGifAdminRole(address gifAdmin) 
+        private 
+        onlyInitializing()
+    {
         
         _createRole(
             GIF_ADMIN_ROLE(), 
@@ -221,8 +262,13 @@ contract RegistryAdmin is
                 maxMemberCount: 2, // TODO decide on max member count
                 name: GIF_ADMIN_ROLE_NAME}));
 
-        // for ReleaseRegistry
+        // for Registry
         FunctionInfo[] memory functions;
+        functions = new FunctionInfo[](1);
+        functions[0] = toFunction(IRegistry.registerRegistry.selector, "registerRegistry");
+        _authorizeTargetFunctions(_registry, GIF_ADMIN_ROLE(), functions);
+
+        // for ReleaseRegistry
         functions = new FunctionInfo[](4);
         functions[0] = toFunction(ReleaseRegistry.createNextRelease.selector, "createNextRelease");
         functions[1] = toFunction(ReleaseRegistry.activateNextRelease.selector, "activateNextRelease");
@@ -233,7 +279,10 @@ contract RegistryAdmin is
         _grantRoleToAccount(GIF_ADMIN_ROLE(), gifAdmin);
     }
     
-    function _setupGifManagerRole(address gifManager) private {
+    function _setupGifManagerRole(address gifManager)
+        private 
+        onlyInitializing()
+    {
 
         _createRole(
             GIF_MANAGER_ROLE(), 
@@ -264,7 +313,10 @@ contract RegistryAdmin is
     }
 
 
-    function _setupReleaseRegistry() private {
+    function _setupReleaseRegistry()
+        private 
+        onlyInitializing()
+    {
 
         _createTarget(_releaseRegistry, RELEASE_REGISTRY_TARGET_NAME, true, false);
 
@@ -278,16 +330,54 @@ contract RegistryAdmin is
                 name: RELEASE_REGISTRY_ROLE_NAME}));
 
         FunctionInfo[] memory functions;
-        functions = new FunctionInfo[](2);
+        functions = new FunctionInfo[](5);
         functions[0] = toFunction(RegistryAdmin.authorizeService.selector, "authorizeService");
         functions[1] = toFunction(RegistryAdmin.grantServiceRoleForAllVersions.selector, "grantServiceRoleForAllVersions");
+        functions[2] = toFunction(RegistryAdmin.revokeServiceRoleForAllVersions.selector, "revokeServiceRoleForAllVersions");
+        functions[3] = toFunction(RegistryAdmin.grantServiceRole.selector, "grantServiceRole");
+        functions[4] = toFunction(RegistryAdmin.revokeServiceRole.selector, "revokeServiceRole");
         _authorizeTargetFunctions(address(this), releaseRegistryRoleId, functions);
 
         _grantRoleToAccount(releaseRegistryRoleId, _releaseRegistry);
     }
 
 
-    function _setupStaking() private {
+    function _setupRegistry()
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _createTarget(_registry, REGISTRY_TARGET_NAME, true, false);
+
+        // registry function authorization for registry service
+        RoleId registryServiceRoleId = RoleIdLib.roleForTypeAndAllVersions(REGISTRY());
+        _createRole(
+            registryServiceRoleId, 
+            toRole({
+                adminRoleId: ADMIN_ROLE(),
+                roleType: RoleType.Contract,
+                maxMemberCount: MAX_NUM_RELEASES,
+                name: REGISTRY_SERVICE_ROLE_NAME}));
+
+        // authorize registry service
+        FunctionInfo[] memory functions;
+        functions = new FunctionInfo[](2);
+        functions[0] = toFunction(IRegistry.register.selector, "register");
+        functions[1] = toFunction(IRegistry.registerWithCustomType.selector, "registerWithCustomType");
+        _authorizeTargetFunctions(_registry, registryServiceRoleId, functions);
+
+        // authorize release registry
+        RoleId releaseRegistryRoleId = RoleIdLib.roleForType(RELEASE());
+        functions = new FunctionInfo[](1);
+        functions[0] = toFunction(IRegistry.registerService.selector, "registerService");
+        _authorizeTargetFunctions(_registry, releaseRegistryRoleId, functions);
+    }
+
+
+    function _setupStaking()
+        private 
+        onlyInitializing()
+    {
         _createTarget(_staking, STAKING_TARGET_NAME, true, false);
         _createTarget(_stakingStore, STAKING_STORE_TARGET_NAME, true, false);
 

package/contracts/registry/RegistryService.sol

@@ -39,8 +39,8 @@ contract RegistryService is
             address initialAuthority
         ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, initialAuthority, owner);
-        registerInterface(type(IRegistryService).interfaceId);
+        _initializeService(registryAddress, initialAuthority, owner);
+        _registerInterface(type(IRegistryService).interfaceId);
     }
 
 

package/contracts/registry/RegistryServiceManager.sol

@@ -21,7 +21,6 @@ contract RegistryServiceManager is
         address registry, // used by implementation 
         bytes32 salt
     ) 
-        ProxyManager(registry)
     {
         if(authority == address(0)) {
             revert ErrorRegistryAccessManagerAuthorityZero();
@@ -33,7 +32,8 @@ contract RegistryServiceManager is
         
         RegistryService srv = new RegistryService{ salt: salt }();
         bytes memory data = abi.encode(registry, authority);
-        IVersionable versionable = deployDetermenistic(
+        IVersionable versionable = initialize(
+            registry,
             address(srv), 
             data,
             salt);

package/contracts/registry/ReleaseRegistry.sol

@@ -194,7 +194,6 @@ contract ReleaseRegistry is
         emit LogReleaseCreation(version, releaseSalt);
     }
 
-    // TODO this function can have 0 args -> use stored addresses from prepareNextRelease()
     function registerService(IService service) 
         external
         restricted // GIF_MANAGER_ROLE
@@ -230,19 +229,26 @@ contract ReleaseRegistry is
         }
 
         // register service with registry
+        // !!! TODO MUST call registry at the end of this function
         nftId = _registry.registerService(info, serviceVersion, serviceDomain);
         service.linkToRegisteredNftId();
         _registeredServices++;
 
         // setup service authorization
+        // !!! TODO service A can call service B while release is not active
         _admin.authorizeService(
             _serviceAuthorization[releaseVersion], 
-            service);
+            service,
+            serviceDomain,
+            serviceVersion);
 
-        // TODO consider to extend this to REGISTRY
         // special roles for registry/staking/pool service
-        if (serviceDomain == STAKING() || serviceDomain == POOL()) {
-            // TODO rename to grantServiceDomainRole()
+        // !!! TODO registry service allowed to call registry while release is not activated (same for staking/pool service and staking)
+        if (
+            serviceDomain == REGISTRY() ||
+            serviceDomain == STAKING() ||
+            serviceDomain == POOL()) 
+        {
             _admin.grantServiceRoleForAllVersions(service, serviceDomain);
         }
     }
@@ -475,7 +481,7 @@ contract ReleaseRegistry is
         // TODO try catch and return false in case of revert
         // or just panic
         // check if contract returns a zero nft id for its own address
-        if (IRegistry(registryAddress).getNftId(registryAddress).eqz()) {
+        if (IRegistry(registryAddress).getNftIdForAddress(registryAddress).eqz()) {
             return false;
         }
 

package/contracts/shared/Component.sol

@@ -52,7 +52,7 @@ abstract contract Component is
         }
     }
 
-    function initializeComponent(
+    function _initializeComponent(
         address authority,
         address registry,
         NftId parentNftId,
@@ -64,11 +64,11 @@ abstract contract Component is
         bytes memory registryData, // writeonly data that will saved in the object info record of the registry
         bytes memory componentData // other component specific data
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegisterable(registry, parentNftId, componentType, isInterceptor, initialOwner, registryData);
+        _initializeRegisterable(registry, parentNftId, componentType, isInterceptor, initialOwner, registryData);
         __AccessManaged_init(authority);
 
         if (token == address(0)) {
@@ -87,8 +87,8 @@ abstract contract Component is
         $._isInterceptor = isInterceptor;
         $._data = componentData;
 
-        registerInterface(type(IAccessManaged).interfaceId);
-        registerInterface(type(IComponent).interfaceId);
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IComponent).interfaceId);
     }
 
 
@@ -206,7 +206,7 @@ abstract contract Component is
 
 
     function isRegistered() public virtual view returns (bool) {
-        return getRegistry().getNftId(address(this)).gtz();
+        return getRegistry().getNftIdForAddress(address(this)).gtz();
     }
 
 

package/contracts/shared/ComponentService.sol

@@ -48,17 +48,17 @@ contract ComponentService is
         virtual override
         initializer()
     {
-        // TODO check this, might no longer be the way, refactor if necessary
-        address registryAddress;
-        address initialOwner;
-        (registryAddress, initialOwner) = abi.decode(data, (address, address));
+        (
+            address registryAddress,
+            address authority
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, address(0), owner);
+        _initializeService(registryAddress, authority, owner);
 
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
         _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
 
-        registerInterface(type(IComponentService).interfaceId);
+        _registerInterface(type(IComponentService).interfaceId);
     }
 
     //-------- component ----------------------------------------------------//
@@ -622,7 +622,7 @@ contract ComponentService is
         }
 
         // check component has not already been registered
-        if (getRegistry().getNftId(componentAddress).gtz()) {
+        if (getRegistry().getNftIdForAddress(componentAddress).gtz()) {
             revert ErrorComponentServiceAlreadyRegistered(componentAddress);
         }
 

package/contracts/shared/ComponentServiceManager.sol

@@ -11,15 +11,18 @@ contract ComponentServiceManager is ProxyManager {
 
     /// @dev initializes proxy manager with service implementation 
     constructor(
-        address registryAddress
+        address authority, 
+        address registry,
+        bytes32 salt
     )
-        ProxyManager(registryAddress)
     {
         ComponentService svc = new ComponentService();
-        bytes memory data = abi.encode(registryAddress, address(this));
-        IVersionable versionable = deploy(
+        bytes memory data = abi.encode(registry, authority);
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
-            data);
+            data,
+            salt);
 
         _componentService = ComponentService(address(versionable));
     }

package/contracts/shared/ComponentVerifyingService.sol

@@ -32,7 +32,7 @@ abstract contract ComponentVerifyingService is
             IInstance instance
         )
     {
-        componentNftId = getRegistry().getNftId(msg.sender);
+        componentNftId = getRegistry().getNftIdForAddress(msg.sender);
         (componentInfo, instance) = _getAndVerifyComponentInfo(
             componentNftId, 
             expectedType,

package/contracts/shared/ContractLib.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {IPolicyHolder} from "./IPolicyHolder.sol";
+
+library ContractLib {
+
+    function isPolicyHolder(address target) external view returns (bool) {
+        return ERC165Checker.supportsInterface(target, type(IPolicyHolder).interfaceId);
+    }
+
+    function isAccessManaged(address target) external view returns (bool) {
+        if (!isContract(target)) {
+            return false;
+        }
+
+        (bool success, ) = target.staticcall(
+            abi.encodeWithSelector(
+                IAccessManaged.authority.selector));
+
+        return success;
+    }
+
+    function isContract(address target) public view returns (bool) {
+        uint256 size;
+        assembly {
+            size := extcodesize(target)
+        }
+        return size > 0;
+    }
+
+    function supportsInterface(address target, bytes4 interfaceId)  external view returns (bool) {
+        return ERC165Checker.supportsInterface(target, interfaceId);
+    }
+}

package/contracts/shared/IInstanceLinkedComponent.sol

@@ -7,21 +7,14 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 import {Amount} from "../type/Amount.sol";
 import {IComponent} from "../shared/IComponent.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
-import {IComponents} from "../instance/module/IComponents.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
-import {IProductService} from "../product/IProductService.sol";
-import {IRegisterable} from "../shared/IRegisterable.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType} from "../type/ObjectType.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
 
 /// @dev component base class
 /// component examples are product, distribution, pool and oracle
 interface IInstanceLinkedComponent is 
     IComponent
 {
-    error ErrorComponentNotProductService(address caller);
     error ErrorComponentNotInstance(NftId instanceNftId);
     error ErrorComponentProductNftAlreadySet();
 

package/contracts/shared/IPolicyHolder.sol

@@ -9,37 +9,27 @@ import {ClaimId} from "../type/ClaimId.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
 import {NftId} from "../type/NftId.sol";
 import {PayoutId} from "../type/PayoutId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 
-/// @dev generic interface for contracts that need to hold policies and receive payouts
-/// GIF will notify policy holder contracts for policy creation and payout execution
+/// @dev Generic interface for contracts that need to hold policies and receive payouts.
+/// The framework notifies policy holder contracts for policy creation/expiry, claim confirmation and payout execution
 interface IPolicyHolder is
     IERC165,
     IERC721Receiver,
     IRegistryLinked
 {
 
-    /// @dev callback function that will be called after successful policy activation
-    /// active policies may open claims under the activated policy
-    function policyActivated(NftId policyNftId) external;
+    /// @dev Callback function that will be called after successful policy activation.
+    /// Active policies may open claims under the activated policy.
+    function policyActivated(NftId policyNftId, Timestamp activatedAt) external;
 
-    /// @dev callback function to indicate the specified policy has expired
-    /// expired policies may no longer open claims
-    /// it is optional for products to notifiy policy holder of expired claims
-    function policyExpired(NftId policyNftId) external;
+    /// @dev Callback function to indicate the specified policy has expired.
+    /// expired policies no longer accept new claims.
+    function policyExpired(NftId policyNftId, Timestamp expiredAt) external;
 
-    /// @dev request for a payout by the requesting policy
-    /// the contract implements its use case specific handling for such requests.
-    /// eg. creation of a pending payout, a corresponding claim against one of the policies held by the IPolicyHolder
-    function requestPayout(NftId requestingPolicyNftId, Amount requestedPayoutAmount) external;
-
-    /// @dev callback function to notify the confirmation of the specified claim
-    /// active policies may open claims under the activated policy
+    /// @dev Callback function to notify the confirmation of the specified claim.
     function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external;
 
-    /// @dev callback function that will be called after a successful payout
-    function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external;
-
-    /// @dev determines policy and claim specific beneficiary address
-    /// returned address will override GIF default where the policy nft holder is treated as beneficiary
-    function getBeneficiary(NftId policyNftId, PayoutId payoutId) external view returns (address beneficiary);
+    /// @dev Callback function to notify the successful payout.
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary) external;
 }

package/contracts/shared/InitializableERC165.sol

@@ -11,13 +11,13 @@ contract InitializableERC165 is
     mapping(bytes4 => bool) private _isSupported;
 
     // @dev initializes with support for ERC165
-    function initializeERC165() public onlyInitializing() {
+    function _initializeERC165() internal onlyInitializing() {
         _isSupported[type(IERC165).interfaceId] = true;
     }
 
     // @dev register support for provided interfaceId
     // includes initialization for ERC165_ID if not yet done
-    function registerInterface(bytes4 interfaceId) public onlyInitializing() {
+    function _registerInterface(bytes4 interfaceId) internal onlyInitializing() {
         _isSupported[interfaceId] = true;
     }