@etherisc/gif-next 3.0.0-cf1abe2-268 → 3.0.0-cf20ffd-765

package/contracts/shared/IComponentService.sol

@@ -18,11 +18,18 @@ interface IComponentService is
 {
     // registerProduct
     error ErrorComponentServiceCallerNotInstance(address caller);
+    error ErrorComponentServiceNotProduct(address product);
     error ErrorComponentServiceTokenInvalid(address token);
 
     // registerComponent
     error ErrorComponentServiceCallerNotProduct(address caller);
+    error ErrorComponentServiceNotComponent(address component);
+
+    error ErrorComponentServiceNotInstanceLinkedComponent(address component);
     error ErrorComponentServiceComponentTypeNotSupported(address component, ObjectType invalid);
+    error ErrorComponentServiceComponentParentInvalid(address component, NftId required, NftId actual);
+    error ErrorComponentServiceComponentReleaseMismatch(address component, VersionPart serviceRelease, VersionPart componentRelease);
+    error ErrorComponentServiceComponentAlreadyRegistered(address component);
     
     error ErrorProductServiceNoDistributionExpected(NftId productNftId);
     error ErrorProductServiceDistributionAlreadyRegistered(NftId productNftId, NftId distributionNftId);
@@ -30,23 +37,52 @@ interface IComponentService is
     error ErrorProductServiceOraclesAlreadyRegistered(NftId productNftId, uint8 expectedOracles);
     error ErrorProductServicePoolAlreadyRegistered(NftId productNftId, NftId poolNftId);
 
+    error ErrorComponentServiceNewWalletAddressZero();
+    error ErrorComponentServiceWalletAddressZero();
+    error ErrorComponentServiceWalletAddressIsSameAsCurrent();
+
     error ErrorComponentServiceWithdrawAmountIsZero();
     error ErrorComponentServiceWithdrawAmountExceedsLimit(Amount withdrawnAmount, Amount withdrawLimit);
-
-    event LogComponentServiceComponentLocked(address component, bool locked);
-    event LogComponentServiceRegistered(NftId instanceNftId, NftId componentNftId, ObjectType componentType, address component, address token, address initialOwner); 
-    event LogComponentServiceComponentFeesWithdrawn(NftId componentNftId, address recipient, address token, Amount withdrawnAmount);
-    event LogComponentServiceProductFeesUpdated(NftId productNftId);
-    event LogComponentServiceDistributionFeesUpdated(NftId distributionNftId);
-    event LogComponentServicePoolFeesUpdated(NftId poolNftId);
+    error ErrorComponentServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
+
+    event LogComponentServiceComponentLocked(address indexed component, bool indexed locked);
+    event LogComponentServiceTokenHandlerDeployed(NftId indexed componentNftId, address indexed tokenHandler, address indexed token);
+    event LogComponentServiceRegistered(NftId indexed instanceNftId, NftId indexed componentNftId, ObjectType indexed componentType, address component, address token, address initialOwner); 
+    event LogComponentServiceComponentFeesWithdrawn(NftId indexed componentNftId, address indexed recipient, Amount indexed withdrawnAmount, address token);
+    event LogComponentServiceProductFeesUpdated(NftId indexed productNftId);
+    event LogComponentServiceDistributionFeesUpdated(NftId indexed distributionNftId);
+    event LogComponentServicePoolFeesUpdated(NftId indexed poolNftId);
     event LogComponentServiceUpdateFee(
-        NftId nftId, 
+        NftId indexed nftId, 
         string feeName, 
         UFixed previousFractionalFee, 
         Amount previousFixedFee,
-        UFixed newFractionalFee, 
-        Amount newFixedFee
+        UFixed indexed newFractionalFee, 
+        Amount indexed newFixedFee
     );
+    event LogComponentServiceProductCreated(
+        NftId indexed productNftId, address indexed productAddress, bool indexed hasDistribution, uint8 expectedNumberOfOracles);
+    event LogComponentServiceProductInitialProductFeesSet(
+        NftId indexed productNftId, 
+        Amount indexed productFeeFixed, UFixed indexed productFeeFractional,
+        Amount processingFeeFixed, UFixed processingFeeFractional);
+    event LogComponentServiceProductInitialDistributionFeesSet(
+        NftId indexed productNftId, 
+        Amount indexed distributionFeeFixed, UFixed indexed distributionFeeFractional,
+        Amount minDistributionOwnerFeeFixed, UFixed minDistributionOwnerFeeFractional);
+    event LogComponentServiceProductInitialPoolFeesSet(
+        NftId indexed productNftId, 
+        Amount indexed poolFeeFixed, UFixed indexed poolFeeFractional,
+        Amount stakingFeeFixed, UFixed stakingFeeFractional,
+        Amount performanceFeeFixed, UFixed performanceFeeFractional);
+    event LogComponentServicePoolCreated(
+        NftId indexed poolNftId, NftId indexed productNftId, address indexed componentAddress, 
+        Amount maxBalanceAmount, UFixed collateralizationLevel, UFixed retentionLevel, 
+        bool isExternallyManaged, bool isVerifyingApplications);
+    event LogComponentServiceDistributionCreated(
+        NftId indexed distributionNftId, NftId indexed productNftId);
+    event LogComponentServiceOracleCreated(
+        NftId indexed oracleNftId, NftId indexed productNftId);
     
     //-------- component ----------------------------------------------------//
 

package/contracts/shared/IInstanceLinkedComponent.sol

@@ -2,26 +2,26 @@
 pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
-import {IComponent} from "../shared/IComponent.sol";
+import {IAuthorizedComponent} from "../shared/IAuthorizedComponent.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {NftId} from "../type/NftId.sol";
 import {ObjectType} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.sol";
 
 /// @dev component base class
 /// component examples are product, distribution, pool and oracle
 interface IInstanceLinkedComponent is 
-    IComponent
+    IAuthorizedComponent
 {
-    error ErrorInstanceLinkedComponentInstanceInvalid();
-    error ErrorInstanceLinkedComponentInstanceMismatch(VersionPart instanceRelease, VersionPart componentRelease);
+    error ErrorInstanceLinkedComponentTypeMismatch(ObjectType requiredType, ObjectType objectType);
+    error ErrorInstanceLinkedComponentNotProduct(NftId nftId, ObjectType objectType);
+
+    /// @dev Withdraw fees from the distribution component. Only component owner is allowed to withdraw fees.
+    /// @param amount the amount to withdraw
+    /// @return withdrawnAmount the amount that was actually withdrawn
+    function withdrawFees(Amount amount) external returns (Amount withdrawnAmount);
 
     /// @dev defines the instance to which this component is linked to
     function getInstance() external view returns (IInstance instance);
 
-    // TODO consider moving to Registerable -> it works with authority
-    /// @dev returns the initial component authorization specification.
-    function getAuthorization() external view returns (IAuthorization authorization);
-
 }

package/contracts/shared/INftOwnable.sol

@@ -5,15 +5,17 @@ import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 import {IRegistryLinked} from "./IRegistryLinked.sol";
 import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 
 interface INftOwnable is
     IERC165,
     IRegistryLinked
 {
-    event LogNftOwnableNftLinkedToAddress(NftId nftId, address owner);
+    event LogNftOwnableNftLinkedToAddress(NftId indexed nftId, address indexed owner);
     
     error ErrorNftOwnableInitialOwnerZero();
     error ErrorNftOwnableNotOwner(address account);
+    error ErrorNftOwnableInvalidType(NftId nftId, ObjectType expectedObjectType);
 
     error ErrorNftOwnableAlreadyLinked(NftId nftId);
     error ErrorNftOwnableContractNotRegistered(address contractAddress);

package/contracts/shared/IRegisterable.sol

@@ -4,11 +4,8 @@ pragma solidity ^0.8.20;
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
 import {INftOwnable} from "./INftOwnable.sol";
+import {IRelease} from "../registry/IRelease.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
-import {IVersionable} from "./IVersionable.sol";
-import {ObjectType} from "../type/ObjectType.sol";
-import {NftId} from "../type/NftId.sol";
-import {VersionPart} from "../type/Version.sol";
 
 /// @title IRegisterable
 /// @dev Marks contracts that are intended to be registered in the registry.
@@ -16,7 +13,7 @@ import {VersionPart} from "../type/Version.sol";
 interface IRegisterable is
     IAccessManaged,
     INftOwnable,
-    IVersionable
+    IRelease
 {
     // __Registerable_init
     error ErrorAuthorityInvalid(address authority);
@@ -24,9 +21,6 @@ interface IRegisterable is
     // onlyActive()
     error ErrorRegisterableNotActive();
 
-    // _checkNftType()
-    error ErrorRegisterableInvalidType(NftId nftId, ObjectType expectedType, VersionPart expectedRelease);
-
     /// @dev Returns true iff this contract managed by its authority is active.
     /// Queries the IAccessManaged.authority().
     function isActive() external view returns (bool active);
@@ -38,10 +32,5 @@ interface IRegisterable is
     function getInitialInfo() 
         external 
         view
-        returns (IRegistry.ObjectInfo memory info);
-
-    function getInitialData() 
-        external 
-        view
-        returns (bytes memory data);
+        returns (IRegistry.ObjectInfo memory);
 }

package/contracts/shared/IRegistryLinked.sol

@@ -5,5 +5,7 @@ import {IRegistry} from "../registry/IRegistry.sol";
 
 interface IRegistryLinked {
 
-    function getRegistry() external pure returns (IRegistry);
+    error ErrorNotRegistry(address registryAddress);
+
+    function getRegistry() external view returns (IRegistry);
 }

package/contracts/shared/IService.sol

@@ -4,14 +4,14 @@ pragma solidity ^0.8.20;
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
 import {IRegisterable} from "./IRegisterable.sol";
-import {IUpgradeable} from "../upgradeability/IUpgradeable.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
 import {ObjectType} from "../type/ObjectType.sol";
 import {RoleId} from "../type/RoleId.sol";
 
 interface IService is 
     IAccessManaged,
     IRegisterable,
-    IUpgradeable
+    IVersionable
 {
     /// @dev returns the domain for this service.
     /// In any GIF release only one service for any given domain may be deployed.

package/contracts/shared/InstanceLinkedComponent.sol

@@ -1,18 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-
-import {Amount} from "../type/Amount.sol";
-import {Component} from "./Component.sol";
-import {IComponentService} from "./IComponentService.sol";
-import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IAuthorizedComponent} from "../shared/IAuthorizedComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
+import {IComponentService} from "./IComponentService.sol";
 import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IOracleService} from "../oracle/IOracleService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {Component} from "./Component.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, INSTANCE, PRODUCT} from "../type/ObjectType.sol";
+import {ObjectType, COMPONENT, INSTANCE, ORACLE, PRODUCT} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {VersionPart} from "../type/Version.sol";
 
 // then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
 // same pattern as for Service which is also upgradeable
@@ -25,20 +33,82 @@ abstract contract InstanceLinkedComponent is
 
     struct InstanceLinkedComponentStorage {
         IInstance _instance; // instance for this component
+        InstanceReader _instanceReader; // instance reader for this component
         IAuthorization _initialAuthorization;
+        IComponentService _componentService;
+        IOracleService _oracleService;
     }
 
+    //--- view functions ----------------------------------------------------//
+
     /// @inheritdoc IInstanceLinkedComponent
-    function getInstance() public view virtual returns (IInstance instance) {
+    function getInstance() public view virtual override returns (IInstance instance) {
         return _getInstanceLinkedComponentStorage()._instance;
     }
 
-    /// @inheritdoc IInstanceLinkedComponent
+
+    /// @inheritdoc IAuthorizedComponent
     function getAuthorization() external view virtual returns (IAuthorization authorization) {
         return _getInstanceLinkedComponentStorage()._initialAuthorization;
     }
 
+
+    /// @inheritdoc IInstanceLinkedComponent
+    function withdrawFees(Amount amount)
+        external
+        virtual
+        restricted()
+        onlyOwner()
+        returns (Amount withdrawnAmount)
+    {
+        return _withdrawFees(amount);
+    }
+
+    //--- internal functions ------------------------------------------------//
+
+    function _sendRequest(
+        NftId oracleNftId,
+        bytes memory requestData,
+        Timestamp expiryAt,
+        string memory callbackMethod
+    )
+        internal
+        virtual
+        returns (RequestId requestId)
+    {
+        return _getInstanceLinkedComponentStorage()._oracleService.request(
+            oracleNftId,
+            requestData,
+            expiryAt,
+            callbackMethod);
+    }
+
+
+    function _cancelRequest(RequestId requestId)
+        internal
+        virtual
+    {
+        _getInstanceLinkedComponentStorage()._oracleService.cancel(requestId);
+    }
+
+
+    function _resendResponse(RequestId requestId)
+        internal
+        virtual
+    {
+        _getInstanceLinkedComponentStorage()._oracleService.resend(requestId);
+    }
+
+
+    function _getInstanceLinkedComponentStorage() private pure returns (InstanceLinkedComponentStorage storage $) {
+        assembly {
+            $.slot := INSTANCE_LINKED_COMPONENT_LOCATION_V1
+        }
+    }
+
+
     function __InstanceLinkedComponent_init(
+        address registry,
         NftId parentNftId,
         string memory name,
         ObjectType componentType,
@@ -46,60 +116,80 @@ abstract contract InstanceLinkedComponent is
         bool isInterceptor,
         address initialOwner
     )
-        internal 
+        internal
         virtual
         onlyInitializing()
     {
-        IInstance instance = _checkAndGetInstance(parentNftId, componentType);
+        // validate registry, nft ids and get parent nft id
+        NftId instanceNftId = _checkAndGetInstanceNftId(
+            registry, 
+            parentNftId, 
+            componentType);
+
+        // set and check linked instance
+        InstanceLinkedComponentStorage storage $ = _getInstanceLinkedComponentStorage();
+        $._instance = IInstance(
+            IRegistry(registry).getObjectAddress(instanceNftId));
 
         // set component specific parameters
         __Component_init(
-            instance.authority(),
+            $._instance.authority(), // instance linked components need to point to instance admin
+            registry, 
             parentNftId, 
             name, 
-            componentType,
+            componentType, 
             isInterceptor, 
             initialOwner, 
             ""); // registry data
 
         // set instance linked specific parameters
-        InstanceLinkedComponentStorage storage $ = _getInstanceLinkedComponentStorage();
-        $._instance = instance;
+        $._instanceReader = $._instance.getInstanceReader();
         $._initialAuthorization = authorization;
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE()));
 
         // register interfaces
         _registerInterface(type(IInstanceLinkedComponent).interfaceId);
     }
 
-    function _checkAndGetInstance(
+
+    function _checkAndGetInstanceNftId(
+        address registryAddress,
         NftId parentNftId,
         ObjectType componentType
     )
-        private
+        internal
         view
-        returns (IInstance instance)
+        returns (NftId instanceNftId)
     {
-        NftId instanceNftId;
-        IRegistry registry = _getRegistry();
-
-        if(componentType == PRODUCT()) {
-            instanceNftId = parentNftId;
-        } else {
-            NftId productNftId = parentNftId;
-            instanceNftId = registry.getParentNftId(productNftId);
+        // if product, then parent is already instance
+        if (componentType == PRODUCT()) {
+            _checkAndGetRegistry(registryAddress, parentNftId, INSTANCE());
+            return parentNftId;
         }
 
-        IRegistry.ObjectInfo memory info = registry.getObjectInfo(instanceNftId);
+        // if not product parent is product, and parent of product is instance
+        IRegistry registry = _checkAndGetRegistry(registryAddress, parentNftId, PRODUCT());
+        return registry.getParentNftId(parentNftId);
+    }
 
-        if (info.objectType != INSTANCE()) {
-            revert ErrorInstanceLinkedComponentInstanceInvalid();
-        }
+    /// @dev checks the and gets registry.
+    /// validates registry using a provided nft id and expected object type.
+    function _checkAndGetRegistry(
+        address registryAddress,
+        NftId objectNftId,
+        ObjectType requiredType
+    )
+        internal
+        view
+        returns (IRegistry registry)
+    {
+        registry = IRegistry(registryAddress);
+        IRegistry.ObjectInfo memory info = registry.getObjectInfo(objectNftId);
 
-        if(info.release != getRelease()) {
-            revert ErrorInstanceLinkedComponentInstanceMismatch(info.release, getRelease());
+        if (info.objectType != requiredType) {
+            revert ErrorInstanceLinkedComponentTypeMismatch(requiredType, info.objectType);
         }
-
-        instance = IInstance(info.objectAddress); 
     }
 
 
@@ -111,7 +201,7 @@ abstract contract InstanceLinkedComponent is
 
 
     function _getComponentInfo() internal virtual override view returns (IComponents.ComponentInfo memory info) {
-        NftId componentNftId = _getRegistry().getNftIdForAddress(address(this));
+        NftId componentNftId = getRegistry().getNftIdForAddress(address(this));
 
         // if registered, attempt to return component info via instance reader
         if (componentNftId.gtz()) {
@@ -131,12 +221,13 @@ abstract contract InstanceLinkedComponent is
 
     /// @dev returns reader for linked instance
     function _getInstanceReader() internal view returns (InstanceReader reader) {
-        return _getInstanceLinkedComponentStorage()._instance.getInstanceReader();
+        return _getInstanceLinkedComponentStorage()._instanceReader;
     }
 
-    function _getInstanceLinkedComponentStorage() private pure returns (InstanceLinkedComponentStorage storage $) {
-        assembly {
-            $.slot := INSTANCE_LINKED_COMPONENT_LOCATION_V1
-        }
+    function _withdrawFees(Amount amount)
+        internal
+        returns (Amount withdrawnAmount)
+    {
+        return _getInstanceLinkedComponentStorage()._componentService.withdrawFees(amount);
     }
 }

package/contracts/shared/NftOwnable.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.20;
 import {InitializableERC165} from "./InitializableERC165.sol";
 import {INftOwnable} from "./INftOwnable.sol";
 import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 
 contract NftOwnable is
@@ -28,15 +29,28 @@ contract NftOwnable is
     }
 
     modifier onlyNftOwner(NftId nftId) {
-        if(!_getRegistry().isOwnerOf(nftId, msg.sender)) {
+        if(!getRegistry().isOwnerOf(nftId, msg.sender)) {
             revert ErrorNftOwnableNotOwner(msg.sender);
         }
         _;
     }
 
+    modifier onlyNftOfType(NftId nftId, ObjectType expectedObjectType) {
+        _checkNftType(nftId, expectedObjectType);
+        _;
+    }
+
+    function _checkNftType(NftId nftId, ObjectType expectedObjectType) internal view {
+        if(expectedObjectType.eqz() || !getRegistry().isObjectType(nftId, expectedObjectType)) {
+            revert ErrorNftOwnableInvalidType(nftId, expectedObjectType);
+        }
+    }
+
+
     /// @dev Initialization for upgradable contracts.
-    // used in __Registerable_init, ProxyManager.initialize
+    // used in __Registerable_init, ProxyManager._preDeployChecksAndSetup
     function __NftOwnable_init(
+        address registry,
         address initialOwner
     )
         internal
@@ -44,6 +58,7 @@ contract NftOwnable is
         onlyInitializing()
     {
         __ERC165_init();
+        __RegistryLinked_init(registry);
 
         if(initialOwner == address(0)) {
             revert ErrorNftOwnableInitialOwnerZero();
@@ -73,7 +88,7 @@ contract NftOwnable is
         NftOwnableStorage storage $ = _getNftOwnableStorage();
 
         if ($._nftId.gtz()) {
-            return _getRegistry().ownerOf($._nftId);
+            return getRegistry().ownerOf($._nftId);
         }
 
         return $._initialOwner;
@@ -93,17 +108,15 @@ contract NftOwnable is
             revert ErrorNftOwnableAlreadyLinked($._nftId);
         }
 
-        NftId nftId = _getRegistry().getNftIdForAddress(nftOwnableAddress);
-
-        if (nftId.eqz()) {
+        if (!getRegistry().isRegistered(nftOwnableAddress)) {
             revert ErrorNftOwnableContractNotRegistered(nftOwnableAddress);
         }
 
-        $._nftId = nftId;
+        $._nftId = getRegistry().getNftIdForAddress(nftOwnableAddress);
 
-        emit LogNftOwnableNftLinkedToAddress(nftId, getOwner());
+        emit LogNftOwnableNftLinkedToAddress($._nftId, getOwner());
 
-        return nftId;
+        return $._nftId;
     }
 
 

package/contracts/shared/PolicyHolder.sol

@@ -23,12 +23,14 @@ contract PolicyHolder is
     // callbacks must only be allowed from the policy and claim services
     // will need a release parameter to fetch the right service addresses for the modifiers
 
-    function __PolicyHolder_init(
+    function _initializePolicyHolder(
+        address registryAddress
     )
         internal
         virtual
         onlyInitializing()
     {
+        __RegistryLinked_init(registryAddress);
         _initializeERC165();
         _registerInterface(type(IPolicyHolder).interfaceId);
     }
@@ -45,7 +47,7 @@ contract PolicyHolder is
     /// @dev empty default implementation
     function payoutExecuted(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary) external virtual {}
 
-    //--- IERC721 functions ---------------// 
+    //--- IERC165 functions ---------------// 
     function onERC721Received(
         address, // operator
         address, // from

package/contracts/shared/Registerable.sol

@@ -9,16 +9,15 @@ import {ContractLib} from "../shared/ContractLib.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
 import {ObjectType} from "../type/ObjectType.sol";
-import {Versionable} from "../shared/Versionable.sol";
 import {VersionPart, VersionPartLib} from "../type/Version.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegisterable} from "./IRegisterable.sol";
+import {IRelease} from "../registry/IRelease.sol";
 
 abstract contract Registerable is
     AccessManagedUpgradeable,
     NftOwnable,
-    Versionable,
     IRegisterable
 {
     // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.shared.Registerable.sol")) - 1)) & ~bytes32(uint256(0xff));
@@ -38,27 +37,14 @@ abstract contract Registerable is
         _;
     }
 
-    modifier onlyNftOfType(NftId nftId, ObjectType expectedObjectType) {
-        _checkNftType(nftId, expectedObjectType);
-        _;
-    }
-
-    // TODO move to registerables verification library
-    // TODO and check the owner here?
-    function _checkNftType(NftId nftId, ObjectType expectedObjectType) internal view {
-        VersionPart expectedRelease = getRelease();
-        if(expectedObjectType.eqz() || !_getRegistry().isObjectType(nftId, expectedObjectType, expectedRelease)) {
-            revert ErrorRegisterableInvalidType(nftId, expectedObjectType, expectedRelease);
-        }
-    }
-
     function __Registerable_init(
         address authority,
+        address registry,
         NftId parentNftId,
         ObjectType objectType,
         bool isInterceptor,
         address initialOwner,
-        bytes memory data
+        bytes memory data // writeonly data that will saved in the object info record of the registry
     )
         internal
         virtual
@@ -68,19 +54,14 @@ abstract contract Registerable is
             revert ErrorAuthorityInvalid(authority);
         }
 
-        VersionPart release = AccessManagerCloneable(authority).getRelease();
-
         __AccessManaged_init(authority);
-        __NftOwnable_init(initialOwner);
-        __Versionable_init(release);
+        __NftOwnable_init(registry, initialOwner);
 
         RegisterableStorage storage $ = _getRegisterableStorage();
         $._parentNftId = parentNftId;
         $._objectType = objectType;
         $._isInterceptor = isInterceptor;
-        if(data.length > 0) { 
-            $._data = data;
-        }
+        $._data = data;
 
         _registerInterface(type(IAccessManaged).interfaceId);
     }
@@ -91,6 +72,13 @@ abstract contract Registerable is
         return !AccessManagerCloneable(authority()).isTargetClosed(address(this));
     }
 
+
+    /// @inheritdoc IRelease
+    function getRelease() public virtual view returns (VersionPart release) {
+        return AccessManagerCloneable(authority()).getRelease();
+    }
+
+
     /// @inheritdoc IRegisterable
     function getInitialInfo() 
         public 
@@ -99,19 +87,14 @@ abstract contract Registerable is
         returns (IRegistry.ObjectInfo memory info) 
     {
         RegisterableStorage storage $ = _getRegisterableStorage();
-        return (
-            IRegistry.ObjectInfo(
-                NftIdLib.zero(),
-                $._parentNftId,
-                $._objectType,
-                getRelease(),
-                $._isInterceptor,
-                address(this))
-        );
-    }
-
-    function getInitialData() public view virtual returns (bytes memory data) {
-        return _getRegisterableStorage()._data;
+        return IRegistry.ObjectInfo(
+            NftIdLib.zero(),
+            $._parentNftId,
+            $._objectType,
+            $._isInterceptor,
+            address(this), 
+            getOwner(),
+            $._data);
     }