@etherisc/gif-next 0.0.2-8d47fa1-080 → 0.0.2-8e4a894-109

package/contracts/shared/Component.sol

@@ -0,0 +1,271 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {IComponent} from "./IComponent.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {InstanceAccessManager} from "../instance/InstanceAccessManager.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, INSTANCE, PRODUCT} from "../type/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
+import {Registerable} from "../shared/Registerable.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {IAccess} from "../instance/module/IAccess.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {VersionPart} from "../type/Version.sol";
+
+// TODO discuss to inherit from oz accessmanaged
+// then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
+// same pattern as for Service which is also upgradeable
+abstract contract Component is
+    Registerable,
+    IComponent,
+    AccessManagedUpgradeable
+{
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.component.Component.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant COMPONENT_LOCATION_V1 = 0xffe8d4462baed26a47154f4b8f6db497d2f772496965791d25bd456e342b7f00;
+
+    struct ComponentStorage {
+        string _name; // unique (per instance) component name
+        IERC20Metadata _token; // token for this component
+        IInstance _instance; // instance for this component
+        address _wallet; // wallet for this component (default = component contract itself)
+        InstanceReader _instanceReader; // instance reader for this component
+        bool _isNftInterceptor; // declares if component is involved in nft transfers
+        NftId _productNftId; // only relevant for components that are linked to a aproduct
+    }
+
+    function _getComponentStorage() private pure returns (ComponentStorage storage $) {
+        assembly {
+            $.slot := COMPONENT_LOCATION_V1
+        }
+    }
+
+    modifier onlyChainNft() {
+        if(msg.sender != getRegistry().getChainNftAddress()) {
+            revert ErrorComponentNotChainNft(msg.sender);
+        }
+        _;
+    }
+
+    function initializeComponent(
+        address registry,
+        NftId instanceNftId,
+        string memory name,
+        address token,
+        ObjectType componentType,
+        bool isInterceptor,
+        address initialOwner,
+        bytes memory registryData // writeonly data that will saved in the object info record of the registry
+    )
+        public
+        virtual
+        onlyInitializing()
+    {
+        initializeRegisterable(registry, instanceNftId, componentType, isInterceptor, initialOwner, registryData);
+
+        // set and check linked instance
+        ComponentStorage storage $ = _getComponentStorage();
+        $._instance = IInstance(
+            getRegistry().getObjectInfo(instanceNftId).objectAddress);
+
+        if(!$._instance.supportsInterface(type(IInstance).interfaceId)) {
+            revert ErrorComponentNotInstance(instanceNftId);
+        }
+
+        // initialize AccessManagedUpgradeable
+        __AccessManaged_init($._instance.authority());
+
+        // set component state
+        $._name = name;
+        $._isNftInterceptor = isInterceptor;
+        $._instanceReader = $._instance.getInstanceReader();
+        $._wallet = address(this);
+        $._token = IERC20Metadata(token);
+
+        registerInterface(type(IAccessManaged).interfaceId);
+        registerInterface(type(IComponent).interfaceId);
+    }
+
+    function lock() external onlyOwner {
+        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(true);
+    }
+    
+    function unlock() external onlyOwner {
+        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(false);
+    }
+
+    function approveTokenHandler(uint256 spendingLimitAmount) external onlyOwner {
+        IComponents.ComponentInfo memory info = getComponentInfo();
+
+        if(info.wallet != address(this)) {
+            revert ErrorComponentWalletNotComponent();
+        }
+
+        info.token.approve(
+            address(info.tokenHandler),
+            spendingLimitAmount);
+
+        emit LogComponentTokenHandlerApproved(spendingLimitAmount);
+    }
+
+    function setWallet(address newWallet)
+        external
+        override
+        onlyOwner
+    {
+        ComponentStorage storage $ = _getComponentStorage();
+
+        address currentWallet = $._wallet;
+        uint256 currentBalance = $._token.balanceOf(currentWallet);
+
+        // checks
+        if (newWallet == address(0)) {
+            revert ErrorComponentWalletAddressZero();
+        }
+
+        if (newWallet == currentWallet) {
+            revert ErrorComponentWalletAddressIsSameAsCurrent();
+        }
+
+        if (currentBalance > 0) {
+            if (currentWallet == address(this)) {
+                // move tokens from component smart contract to external wallet
+            } else {
+                // move tokens from external wallet to component smart contract or another external wallet
+                uint256 allowance = $._token.allowance(currentWallet, address(this));
+                if (allowance < currentBalance) {
+                    revert ErrorComponentWalletAllowanceTooSmall(currentWallet, newWallet, allowance, currentBalance);
+                }
+            }
+        }
+
+        // effects
+        $._wallet = newWallet;
+        emit LogComponentWalletAddressChanged(currentWallet, newWallet);
+
+        // interactions
+        if (currentBalance > 0) {
+            // transfer tokens from current wallet to new wallet
+            if (currentWallet == address(this)) {
+                // transferFrom requires self allowance too
+                $._token.approve(address(this), currentBalance);
+            }
+            
+            SafeERC20.safeTransferFrom($._token, currentWallet, newWallet, currentBalance);
+            emit LogComponentWalletTokensTransferred(currentWallet, newWallet, currentBalance);
+        }
+    }
+
+    function setProductNftId(NftId productNftId)
+        external
+        override
+    {
+        ComponentStorage storage $ = _getComponentStorage();
+
+        // verify caller is product service
+        if(msg.sender != _getServiceAddress(PRODUCT())) {
+            revert ErrorComponentNotProductService(msg.sender);
+        }
+
+        // verify component is not yet linked to a product
+        if($._productNftId.gtz()) {
+            revert ErrorComponentProductNftAlreadySet();
+        }
+
+        $._productNftId = productNftId;
+    }
+
+    function nftMint(address to, uint256 tokenId) 
+        external 
+        virtual
+        onlyChainNft
+    {}
+
+    /// @dev callback function for nft transfers
+    /// may only be called by chain nft contract.
+    /// do not override this function to implement business logic for handling transfers
+    /// override internal function _nftTransferFrom instead
+    function nftTransferFrom(address from, address to, uint256 tokenId)
+        external
+        virtual
+        onlyChainNft
+    {
+        _nftTransferFrom(from, to, tokenId);
+    }
+
+    function getWallet() public view override returns (address walletAddress)
+    {
+        return _getComponentStorage()._wallet;
+    }
+
+    function getToken() public view override returns (IERC20Metadata token) {
+        return _getComponentStorage()._token;
+    }
+
+    function getTokenHandler() public view returns (TokenHandler tokenHandler) {
+        return getComponentInfo().tokenHandler;
+    }
+
+    function isNftInterceptor() public view override returns(bool isInterceptor) {
+        return _getComponentStorage()._isNftInterceptor;
+    }
+
+    function getInstance() public view override returns (IInstance instance) {
+        return _getComponentStorage()._instance;
+    }
+
+    function getName() public view override returns(string memory name) {
+        return _getComponentStorage()._name;
+    }
+
+    function getProductNftId() public view override returns (NftId productNftId) {
+        return _getComponentStorage()._productNftId;
+    }
+
+    function getComponentInfo() public view returns (IComponents.ComponentInfo memory info) {
+        info = _getInstanceReader().getComponentInfo(getNftId());
+
+        // fallback to initial info (wallet is always != address(0))
+        if(info.wallet == address(0)) {
+            info = _getInitialInfo();
+        }
+    }
+
+    /// @dev defines initial component specification
+    /// overwrite this function according to your use case
+    function _getInitialInfo()
+        internal
+        view 
+        virtual
+        returns (IComponents.ComponentInfo memory info)
+    { }
+
+
+    /// @dev internal function for nft transfers.
+    /// handling logic that deals with nft transfers need to overwrite this function
+    function _nftTransferFrom(address from, address to, uint256 tokenId)
+        internal
+        virtual
+    { }
+
+    /// @dev returns reader for linked instance
+    function _getInstanceReader() internal view returns (InstanceReader reader) {
+        return _getComponentStorage()._instanceReader;
+    }
+
+    /// @dev returns the service address for the specified domain
+    /// gets address via lookup from registry using the major version form the linked instance
+    function _getServiceAddress(ObjectType domain) internal view returns (address service) {
+        VersionPart majorVersion = _getComponentStorage()._instance.getMajorVersion();
+        return getRegistry().getServiceAddress(domain, majorVersion);
+    }
+}

package/contracts/shared/ComponentService.sol

@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponent} from "./IComponent.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IAccess} from "../instance/module/IAccess.sol";
+import {ObjectType, INSTANCE, REGISTRY} from "../type/ObjectType.sol";
+import {NftId} from "../type/NftId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+import {Service} from "../shared/Service.sol";
+import {InstanceService} from "../instance/InstanceService.sol";
+import {InstanceAccessManager} from "../instance/InstanceAccessManager.sol";
+
+abstract contract ComponentService is
+    Service
+{
+
+    error ErrorComponentServiceNotComponent(address component);
+    error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
+    error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
+    error ErrorComponentServiceExpectedRoleMissing(NftId instanceNftId, RoleId requiredRole, address sender);
+    error ErrorComponentServiceComponentLocked(address component);
+    error ErrorComponentServiceSenderNotService(address sender);
+    error ErrorComponentServiceComponentTypeInvalid(address component, ObjectType expectedType, ObjectType foundType);
+
+    /// @dev modifier to check if caller is a registered service
+    modifier onlyService() {
+        address caller = msg.sender;
+        if(!getRegistry().isRegisteredService(caller)) {
+            revert ErrorComponentServiceSenderNotService(caller);
+        }
+        _;
+    }
+
+    // view functions
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        return IRegistryService(_getServiceAddress(REGISTRY()));
+    }
+
+    function getInstanceService() public view returns (InstanceService) {
+        return InstanceService(_getServiceAddress(INSTANCE()));
+    }
+
+    // internal functions
+    function _checkComponentForRegistration(
+        address componentAddress,
+        ObjectType requiredType,
+        RoleId requiredRole
+    )
+        internal
+        view
+        returns (
+            IComponent component,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        )
+    {
+        // component may only be registerd by initial owner of component
+        owner = msg.sender;
+
+        // check this is a component
+        component = IComponent(componentAddress);
+        if(!component.supportsInterface(type(IComponent).interfaceId)) {
+            revert ErrorComponentServiceNotComponent(componentAddress);
+        }
+
+        // check component is of required type
+        IRegistry.ObjectInfo memory componentInfo = component.getInitialInfo();
+        if(componentInfo.objectType != requiredType) {
+            revert ErrorComponentServiceInvalidType(componentAddress, requiredType, componentInfo.objectType);
+        }
+
+        // check msg.sender is component owner
+        address initialOwner = componentInfo.initialOwner;
+        if(owner != initialOwner) {
+            revert ErrorComponentServiceSenderNotOwner(componentAddress, componentInfo.initialOwner, owner);
+        }
+
+        // check instance has assigned required role to owner
+        instanceNftId = componentInfo.parentNftId;
+        instance = _getInstance(instanceNftId);
+        if(!instance.getInstanceAccessManager().hasRole(requiredRole, owner)) {
+            revert ErrorComponentServiceExpectedRoleMissing(instanceNftId, requiredRole, owner);
+        }
+    }
+
+    // internal view functions
+    function _getAndVerifyCallingComponentAndInstance(
+        ObjectType expectedType // assume always of `component` type
+    )
+        internal
+        view
+        returns(
+            NftId componentNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        )
+    {
+        componentNftId = getRegistry().getNftId(msg.sender);
+        (componentInfo, instance) = _getAndVerifyComponentInfoAndInstance(componentNftId, expectedType);
+
+        // locked component can not call services
+        if (instance.getInstanceAccessManager().isTargetLocked(componentInfo.objectAddress)) {
+            revert IAccess.ErrorIAccessTargetLocked(componentInfo.objectAddress);
+        }
+    }
+
+    function _getAndVerifyComponentInfoAndInstance(
+        NftId componentNftId,
+        ObjectType expectedType // assume always of `component` type
+    )
+        internal
+        view
+        returns(
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        )
+    {
+        componentInfo = getRegistry().getObjectInfo(componentNftId);
+        if(componentInfo.objectType != expectedType) {
+            revert ErrorComponentServiceComponentTypeInvalid(
+                componentInfo.objectAddress, 
+                expectedType, 
+                componentInfo.objectType);
+        }
+
+        instance = _getInstance(componentInfo.parentNftId);
+    }
+    // assume componentNftId is always of `instance` type
+    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            getRegistry().getObjectInfo(
+                instanceNftId).objectAddress);
+    }
+    // assume componentNftId is always of `component` type
+    /*function _getInstanceForComponent(NftId componentNftId) internal view returns (IInstance) {
+        NftId instanceNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
+    }*/
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
+    }
+}

package/contracts/shared/ERC165.sol

@@ -1,21 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {IERC165} from "@openzeppelin5/contracts/utils/introspection/IERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-contract ERC165 is IERC165 {
+contract ERC165 is
+    Initializable,
+    IERC165
+{
     mapping(bytes4 => bool) private _isSupported;
 
-    constructor() {
-        // register support for ERC165
-        _registerInterface(type(IERC165).interfaceId);
+    // @dev initializes with support for ERC165
+    function initializeERC165() public onlyInitializing() {
+        _isSupported[type(IERC165).interfaceId] = true;
     }
 
-    function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
-        return _isSupported[interfaceId];
+    // @dev register support for provided interfaceId
+    // includes initialization for ERC165_ID if not yet done
+    function registerInterface(bytes4 interfaceId) public onlyInitializing() {
+        _isSupported[interfaceId] = true;
     }
 
-    function _registerInterface(bytes4 interfaceId) internal {
-        _isSupported[interfaceId] = true;
+    function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
+        return _isSupported[interfaceId];
     }
 }

package/contracts/shared/IComponent.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.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 {ITransferInterceptor} from "../registry/ITransferInterceptor.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 IComponent is 
+    IRegisterable,
+    ITransferInterceptor,
+    IAccessManaged
+{
+    error ErrorComponentNotChainNft(address caller);
+    error ErrorComponentNotProductService(address caller);
+    error ErrorComponentNotInstance(NftId instanceNftId);
+    error ErrorComponentProductNftAlreadySet();
+
+    error ErrorComponentWalletAddressZero();
+    error ErrorComponentWalletAddressIsSameAsCurrent();
+    error ErrorComponentWalletAllowanceTooSmall(address oldWallet, address newWallet, uint256 allowance, uint256 balance);
+
+    error ErrorComponentWalletNotComponent();
+
+    event LogComponentWalletAddressChanged(address oldWallet, address newWallet);
+    event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
+
+    event LogComponentTokenHandlerApproved(uint256 limit);
+
+    /// @dev locks component to disable functions that may change state related to this component, the only exception is function "unlock"
+    /// only component owner (nft holder) is authorizes to call this function
+    function lock() external;
+
+    /// @dev unlocks component to (re-)enable functions that may change state related to this component
+    /// only component owner (nft holder) is authorizes to call this function
+    function unlock() external;
+
+    /// @dev approves token hanlder to spend up to the specified amount of tokens
+    /// reverts if component wallet is not component itself
+    /// only component owner (nft holder) is authorizes to call this function
+    function approveTokenHandler(uint256 spendingLimitAmount) external;
+
+    /// @dev sets the wallet address for the component
+    /// if the current wallet has tokens, these will be transferred
+    /// if the new wallet address is externally owned, an approval from the 
+    /// owner of the external wallet for the component to move all tokens must exist
+    function setWallet(address walletAddress) external;
+
+    /// @dev only product service may set product nft id during registration of product setup
+    function setProductNftId(NftId productNftId) external;
+
+    /// @dev defines the instance to which this component is linked to
+    function getInstance() external view returns (IInstance instance);
+
+    /// @dev returns the name of this component
+    /// to successfully register the component with an instance the name MUST be unique in the linked instance
+    function getName() external view returns (string memory name);
+
+    /// @dev defines which ERC20 token is used by this component
+    function getToken() external view returns (IERC20Metadata token);
+
+    /// @dev returns token handler for this component
+    /// only registered components return a non zero token handler
+    function getTokenHandler() external view returns (TokenHandler tokenHandler);
+
+    /// @dev defines the wallet address used to hold the ERC20 tokens related to this component
+    /// the default address is the component token address
+    function getWallet() external view returns (address walletAddress);
+
+    /// @dev defines the product to which this component is linked to
+    /// this is only relevant for pool and distribution components
+    function getProductNftId() external view returns (NftId productNftId);
+
+    function isNftInterceptor() external view returns(bool isInterceptor);
+
+    /// @dev returns component infos for this pool
+    /// when registered with an instance the info is obtained from the data stored in the instance
+    /// when not registered the function returns the info from the component contract
+    function getComponentInfo() external view returns (IComponents.ComponentInfo memory info);
+}

package/contracts/shared/INftOwnable.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {IRegistryLinked} from "./IRegistryLinked.sol";
+import {NftId} from "../type/NftId.sol";
+
+interface INftOwnable is
+    IERC165,
+    IRegistryLinked
+{
+    error ErrorNftOwnableInitialOwnerZero();
+    error ErrorNftOwnableNotOwner(address account);
+
+    error ErrorNftOwnableAlreadyLinked(NftId nftId);
+    error ErrorNftOwnableContractNotRegistered(address contractAddress);
+
+    function linkToRegisteredNftId() external;
+
+    function getNftId() external view returns (NftId);
+    function getOwner() external view returns (address);
+}

package/contracts/shared/IPolicyHolder.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId} from "../type/PayoutId.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
+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 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 notify the confirmation of the specified claim
+    /// active policies may open claims under the activated policy
+    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, ClaimId claimId) external view returns (address beneficiary);
+}

package/contracts/shared/IRegisterable.sol

@@ -1,22 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC165} from "@openzeppelin5/contracts/utils/introspection/IERC165.sol";
-
+import {INftOwnable} from "./INftOwnable.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
-import {ObjectType} from "../types/ObjectType.sol";
-
-import {IOwnable} from "./IOwnable.sol";
 
-interface IRegisterable is IERC165, IOwnable {
-    function getRegistry() external view returns (IRegistry registry);
-
-    function getNftId() external view returns (NftId nftId);
+interface IRegisterable is
+    INftOwnable
+{
 
     function getInitialInfo() 
         external 
         view
-        returns (IRegistry.ObjectInfo memory, bytes memory data);
-
+        returns (IRegistry.ObjectInfo memory);
 }

package/contracts/shared/IRegistryLinked.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IRegistry} from "../registry/IRegistry.sol";
+
+interface IRegistryLinked {
+
+    error ErrorNotRegistry(address registryAddress);
+
+    function getRegistry() external view returns (IRegistry);
+}

package/contracts/shared/IService.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {IRegisterable} from "./IRegisterable.sol";
+import {IVersionable} from "./IVersionable.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+
+interface IService is 
+    IRegisterable,
+    IVersionable,
+    IAccessManaged
+{
+    error ErrorServiceNotImplemented();
+
+    function getDomain() external pure returns(ObjectType serviceDomain);
+}