@etherisc/gif-next 0.0.2-ed4dd55 → 0.0.2-edd8f00-238

package/contracts/shared/ComponentVerifyingService.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IInstance} from "../instance/IInstance.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT, DISTRIBUTION, ORACLE, POOL, PRODUCT} from "../type/ObjectType.sol";
+import {Service} from "../shared/Service.sol";
+
+
+abstract contract ComponentVerifyingService is 
+    Service
+{
+
+    error ErrorComponentVerifyingServiceComponentTypeInvalid(NftId componentNftId, ObjectType expectedType, ObjectType actualType);
+    error ErrorComponentVerifyingServiceComponentIsLocked(NftId componentNftId);
+
+    /// @dev based on the sender address returns the corresponding components nft id, info and instance.
+    /// the function reverts iff:
+    /// - there is no such component
+    /// - the component has the wrong object type
+    /// - the component is locked
+    function _getAndVerifyActiveComponent(
+        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) = _getAndVerifyComponentInfo(
+            componentNftId, 
+            expectedType,
+            true); // only active
+    }
+
+
+    /// @dev returns the component info and instance contract reference given a component nft id
+    /// the function reverts iff:
+    /// - there is no such component
+    /// - the component has the wrong object type
+    function _getAndVerifyComponentInfo(
+        NftId componentNftId,
+        ObjectType expectedType, // assume always of `component` type
+        bool onlyActive
+    )
+        internal
+        virtual
+        view
+        returns(
+            IRegistry.ObjectInfo memory info, 
+            IInstance instance
+        )
+    {
+        IRegistry registry = getRegistry();
+        info = registry.getObjectInfo(componentNftId);
+
+        // if not COMPONENT require exact match
+        if(expectedType != COMPONENT()) {
+            // ensure component is of expected type
+            if(info.objectType != expectedType) {
+                revert ErrorComponentVerifyingServiceComponentTypeInvalid(
+                    componentNftId,
+                    expectedType,
+                    info.objectType);
+            }
+        } else {
+            if(!(info.objectType == PRODUCT()
+                || info.objectType == POOL()
+                || info.objectType == DISTRIBUTION()
+                || info.objectType == ORACLE()
+            ))
+            {
+                revert ErrorComponentVerifyingServiceComponentTypeInvalid(
+                    componentNftId,
+                    expectedType,
+                    info.objectType);
+            }
+        }
+
+        instance = _getInstance(info.parentNftId);
+
+        // ensure component is not locked
+        if (onlyActive) {
+            if (instance.getInstanceAccessManager().isTargetClosed(info.objectAddress)) {
+                revert ErrorComponentVerifyingServiceComponentIsLocked(componentNftId);
+            }
+        }
+    }
+
+
+    /// @dev returns the linked product nft id for the specified component
+    function _getProductNftId(
+        InstanceReader instanceReader,
+        NftId componentNftId
+    )
+        internal
+        virtual
+        view
+        returns (NftId productNftId)
+    {
+        return instanceReader.getComponentInfo(componentNftId).productNftId;
+    }
+
+
+    /// @dev returns an IInstance contract reference for the specified instance nft id
+    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            getRegistry().getObjectInfo(
+                instanceNftId).objectAddress);
+    }
+}

package/contracts/shared/ERC165.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+contract ERC165 is
+    Initializable,
+    IERC165
+{
+    mapping(bytes4 => bool) private _isSupported;
+
+    // @dev initializes with support for ERC165
+    function initializeERC165() public 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() {
+        _isSupported[interfaceId] = true;
+    }
+
+    function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
+        return _isSupported[interfaceId];
+    }
+}

package/contracts/shared/IAccessAdmin.sol

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {RoleId} from "../type/RoleId.sol";
+import {Selector} from "../type/Selector.sol";
+import {Str} from "../type/String.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IAccessAdmin is 
+    IAccessManaged
+{
+
+    // roles
+    event LogRoleCreated(RoleId roleId, RoleId roleAdminId, string name);
+    event LogRoleDisabled(RoleId roleId, bool disabled, Timestamp disabledAtOld);
+    event LogTargetCreated(address target, string name);
+    event LogFunctionCreated(address target, Selector selector, string name);
+
+    // only deployer modifier
+    error ErrorNotDeployer();
+
+    // only role admin modifier
+    error ErrorNotAdminOfRole(RoleId adminRoleId);
+
+    // only role owner modifier
+    error ErrorNotRoleOwner(RoleId roleId);
+
+    // initialize authority
+    error ErrorAuthorityAlreadySet();
+    error ErrorAdminRoleMissing();
+
+    // create role
+    error ErrorRoleAlreadyCreated(RoleId roleId, string name);
+    error ErrorRoleAdminNotExisting(RoleId adminRoleId);
+    error ErrorRoleNameEmpty(RoleId roleId);
+    error ErrorRoleNameAlreadyExists(RoleId roleId, string name, RoleId existingRoleId);
+
+    // grant/revoke/renounce role
+    error ErrorRoleUnknown(RoleId roleId);
+    error ErrorRoleIsLocked(RoleId roleId);
+    error ErrorRoleIsDisabled(RoleId roleId);
+    error ErrorRoleMembersLimitReached(RoleId roleId, uint256 memberCountLimit);
+    error ErrorRoleRemovalDisabled(RoleId roleId);
+
+    // create target
+    error ErrorTargetAlreadyCreated(address target, string name);
+    error ErrorTargetNameEmpty(address target);
+    error ErrorTargetNameAlreadyExists(address target, string name, address existingTarget);
+    error ErrorTargetNotAccessManaged(address target);
+    error ErrorTargetAuthorityMismatch(address expectedAuthority, address actualAuthority);
+
+    // lock target
+    error ErrorTagetNotLockable();
+
+    // authorize target functions
+    error ErrorAuthorizeForAdminRoleInvalid(address target);
+
+    // check target
+    error ErrorTargetUnknown(address target);
+
+    struct RoleInfo {
+        RoleId adminRoleId;
+        Str name;
+        uint256 maxMemberCount;
+        bool memberRemovalDisabled;
+        Timestamp disabledAt;
+        bool exists;
+    }
+
+    struct RoleNameInfo {
+        RoleId roleId;
+        bool exists;
+    }
+
+    struct TargetInfo {
+        Str name;
+        Timestamp createdAt;
+    }
+
+    struct Function {
+        Selector selector; // function selector
+        Str name; // function name
+    }
+
+    /// @dev Create a new named role using the specified parameters.
+    /// The adminRoleId refers to the required role to grant/revoke the newly created role.
+    /// permissioned: the caller must have the manager role (getManagerRole).
+    function createRole(
+        RoleId roleId, 
+        RoleId adminRoleId, 
+        string memory name,
+        uint256 maxMemberCount,
+        bool memberRemovalDisabled
+    )
+        external;
+
+    /// @dev Set the disabled status of the speicified role.
+    /// Role disabling only prevents the role from being granted to new accounts.
+    /// Existing role members may still execute functions that are authorized for that role.
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    function setRoleDisabled(RoleId roleId, bool disabled) external;
+
+    /// @dev Grant the specified account the provided role.
+    /// Permissioned: the caller must have the roles admin role.
+    function grantRole(address account, RoleId roleId) external;
+
+    /// @dev Revoke the provided role from the specified account.
+    /// Permissioned: the caller must have the roles admin role.
+    function revokeRole(address account, RoleId roleId) external;
+
+    /// @dev Removes the provided role from the caller
+    function renounceRole(RoleId roleId) external;
+
+    /// @dev Create a new named target.
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    function createTarget(address target, string memory name) external;
+
+    /// @dev Set the locked status of the speicified contract.
+    /// IMPORTANT: using this function the AccessManager might itself be put into locked state from which it cannot be unlocked again.
+    /// Overwrite this function if a different use case specific behaviour is required.
+    /// Alternatively, add specific function to just unlock this contract without a restricted() modifier.
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    function setTargetLocked(address target, bool locked) external;
+
+    /// @dev Specifies which functions of the target can be accessed by the provided role.
+    /// Previously existing authorizations will be overwritten.
+    /// Authorizing the admin role is not allowed, use function unauthorizedFunctions for this.
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    function authorizeFunctions(address target, RoleId roleId, Function[] memory functions) external;
+
+    /// @dev Specifies for which functionss to remove any previous authorization
+    /// Permissioned: the caller must have the manager role (getManagerRole).
+    function unauthorizeFunctions(address target, Function[] memory functions) external;
+
+    //--- view functions ----------------------------------------------------//
+
+    function roles() external view returns (uint256 numberOfRoles);
+    function getRoleId(uint256 idx) external view returns (RoleId roleId);
+    function getAdminRole() external view returns (RoleId roleId);
+    function getManagerRole() external view returns (RoleId roleId);
+    function getPublicRole() external view returns (RoleId roleId);
+
+    function roleExists(RoleId roleId) external view returns (bool exists); 
+    function isRoleDisabled(RoleId roleId) external view returns (bool roleIsActive);
+    function getRoleInfo(RoleId roleId) external view returns (RoleInfo memory roleInfo);
+    function getRoleForName(Str name) external view returns (RoleNameInfo memory);
+
+    function hasRole(address account, RoleId roleId) external view returns (bool);
+    function roleMembers(RoleId roleId) external view returns (uint256 numberOfMembers);
+    function getRoleMember(RoleId roleId, uint256 idx) external view returns (address account);
+
+    function targetExists(address target) external view returns (bool exists);
+    function isTargetLocked(address target) external view returns (bool locked);
+    function targets() external view returns (uint256 numberOfTargets);
+    function getTargetAddress(uint256 idx) external view returns (address target);
+    function getTargetInfo(address target) external view returns (TargetInfo memory targetInfo);
+    function getTargetForName(Str name) external view returns (address target);
+
+    function authorizedFunctions(address target) external view returns (uint256 numberOfFunctions);
+    function getAuthorizedFunction(address target, uint256 idx) external view returns (Function memory func, RoleId roleId);
+    function canCall(address caller, address target, Selector selector) external view returns (bool can);
+
+    function toFunction(bytes4 selector, string memory name) external pure returns (Function memory);
+    function isAccessManaged(address target) external view returns (bool);
+    function deployer() external view returns (address);
+}

package/contracts/shared/IAccessManagerExtended.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManager.sol)
+
+pragma solidity ^0.8.20;
+
+import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
+
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IAccessManagerExtended is IAccessManager {
+    // Structure that stores the details for a target contract.
+    struct TargetInfo {
+        address taddress;
+        //IAccess.Type ttype;
+        string name;
+        Timestamp createdAt;
+        //Timestamp updatedAt;
+    }
+
+    // Structure that stores the details of a role.
+    struct RoleInfo {
+        uint64 id;
+        //IAccess.Type rtype;
+        string name;
+        Timestamp createdAt;
+    }
+
+    event LogRoleCreation(uint64 roleId, string name);// IAccess.Type rtype);
+    event LogTargetCreation(address target, string name);// IAccess.Type ttype);
+
+    error AccessManagerRoleIdNotExists(uint64 roleId);
+    error AccessManagerRoleIdAlreadyExists(uint64 roleId);
+    error AccessManagerRoleNameAlreadyExists(uint64 newRoleId, uint64 existingRoleId, string duplicateName);
+    error AccessManagerRoleIdZero();
+    error AccessManagerRoleNameEmpty(uint64 roleId);
+    error AccessManagerRoleIdTooBig(uint64 roleId);
+
+    error AccessManagerTargetAlreadyExists(address target);
+    error AccessManagerTargetNotExists(address target);
+    error AccessManagerTargetNameAlreadyExists(address newTarget, address existingTarget, string duplicateName);
+    error AccessManagerTargetAddressZero();
+    error AccessManagerTargetNameEmpty(address target);
+    error AccessManagerTargetAuthorityInvalid(address target, address targetAuthority);
+
+    function getRoleMembers(uint64 roleId) external view returns (uint256 numberOfMembers);
+
+    function getRoleMember(uint64 roleId, uint256 idx) external view returns (address member);
+
+    function getRoleId(uint256 idx) external view returns (uint64 roleId);
+
+    // TODO returns ADMIN_ROLE id for non existent name
+    function getRoleId(string memory name) external view returns (uint64 roleId);
+
+    function getRoles() external view returns (uint256 numberOfRoles);
+
+    function isRoleExists(uint64 roleId) external view returns (bool exists);
+
+    function getRoleInfo(uint64 roleId) external view returns (RoleInfo memory);
+
+    function isRoleNameExists(string memory name) external view returns (bool);
+
+    function isTargetExists(address target) external view returns (bool);
+
+    function isTargetNameExists(string memory name) external view returns (bool);
+    
+    function getTargetAddress(string memory name) external view returns(address targetAddress);
+
+    function getTargetInfo(address target) external view returns (TargetInfo memory);
+
+
+    function createRole(uint64 roleId, string memory roleName/*, IAccess.Type rtype*/) external;
+
+    function createTarget(address target, string memory name/*, IAccess.Type.Custom*/) external;
+}

package/contracts/shared/IAccessManagerExtendedWithDisable.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IAccessManagerExtended} from "./IAccessManagerExtended.sol";
+
+import {Timestamp} from "../type/Timestamp.sol";
+import {VersionPart} from "../type/Version.sol";
+import {Seconds} from "../type/Seconds.sol";
+
+interface IAccessManagerExtendedWithDisable is IAccessManagerExtended {
+
+    error AccessManagerDisabled();
+
+    function disable(Seconds delay) external;
+    function enable() external;
+    function getVersion() external view returns (VersionPart version);
+}

package/contracts/shared/IComponent.sol

@@ -0,0 +1,70 @@
+// 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 {Amount} from "../type/Amount.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IRegisterable} from "../shared/IRegisterable.sol";
+import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+
+/// @dev component base class
+/// component examples are staking, product, distribution, pool and oracle
+interface IComponent is 
+    IAccessManaged,
+    IRegisterable,
+    ITransferInterceptor
+{
+    error ErrorComponentNotChainNft(address caller);
+
+    error ErrorComponentTokenAddressZero();
+    error ErrorComponentNameLengthZero();
+    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(address token, Amount limit);
+
+    /// @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(Amount 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 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
+    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 returns true iff this compoent intercepts nft minting and transfers for objects registered by this component
+    function isNftInterceptor() external view returns(bool isInterceptor);
+
+    /// @dev returns true iff this component is registered with the registry
+    function isRegistered() external view returns (bool);
+
+    /// @dev returns the component infos for this component
+    /// for a non registered component the function returns getInitialComponentInfo()
+    function getComponentInfo() external view returns (IComponents.ComponentInfo memory info);
+
+    /// @dev returns the iniital component infos for this component
+    function getInitialComponentInfo() external view returns (IComponents.ComponentInfo memory info);
+}

package/contracts/shared/IComponentService.sol

@@ -0,0 +1,102 @@
+// 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 {Amount} from "../type/Amount.sol";
+import {Fee} from "../type/Fee.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
+import {IProductService} from "../product/IProductService.sol";
+import {IRegisterable} from "../shared/IRegisterable.sol";
+import {IService} from "../shared/IService.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {UFixed} from "../type/UFixed.sol";
+
+/// @dev component base class
+/// component examples are staking, product, distribution, pool and oracle
+interface IComponentService is 
+    IService
+{
+    error ErrorComponentServiceNewWalletAddressZero();
+    error ErrorComponentServiceWalletAddressZero();
+    error ErrorComponentServiceWalletAddressIsSameAsCurrent();
+
+    event LogComponentServiceWalletAddressChanged(NftId componentNftId, address currentWallet, address newWallet);
+    event LogComponentServiceProductFeesUpdated(NftId productNftId);
+    event LogComponentServiceDistributionFeesUpdated(NftId distributionNftId);
+    event LogComponentServicePoolFeesUpdated(NftId poolNftId);
+    event LogComponentServiceUpdateFee(
+        NftId nftId, 
+        string feeName, 
+        UFixed previousFractionalFee, 
+        uint256 previousFixedFee,
+        UFixed newFractionalFee, 
+        uint256 newFixedFee
+    );
+
+    //-------- component ----------------------------------------------------//
+
+    /// @dev sets the components associated wallet address
+    function setWallet(address newWallet) external;
+
+    /// @dev locks the component associated with the caller
+    function lock() external;
+
+    /// @dev unlocks the component associated with the caller
+    function unlock() external;
+
+    //-------- product ------------------------------------------------------//
+
+    /// @dev registers the sending component as a product component
+    function registerProduct() external;
+
+    function setProductFees(
+        Fee memory productFee, // product fee on net premium
+        Fee memory processingFee // product fee on payout amounts        
+    ) external;
+
+    function increaseProductFees(InstanceStore instanceStore, NftId productNftId, Amount feeAmount) external;
+    function decreaseProductFees(InstanceStore instanceStore, NftId productNftId, Amount feeAmount) external;
+
+    //-------- distribution -------------------------------------------------//
+
+    /// @dev registers the sending component as a distribution component
+    function registerDistribution() external;
+
+    function setDistributionFees(
+        Fee memory distributionFee, // distribution fee for sales that do not include commissions
+        Fee memory minDistributionOwnerFee // min fee required by distribution owner (not including commissions for distributors)
+    ) external;
+
+    function increaseDistributionBalance(InstanceStore instanceStore, NftId distributionNftId, Amount amount, Amount feeAmount) external;
+    function decreaseDistributionBalance(InstanceStore instanceStore, NftId distributionNftId, Amount amount, Amount feeAmount) external;
+
+    //-------- oracle -------------------------------------------------------//
+
+    /// @dev registers the sending component as an oracle component
+    function registerOracle() external;
+
+    //-------- pool ---------------------------------------------------------//
+
+    /// @dev registers the sending component as a pool component
+    function registerPool() external;
+
+    function setPoolFees(
+        Fee memory poolFee, // pool fee on net premium
+        Fee memory stakingFee, // pool fee on staked capital from investor
+        Fee memory performanceFee // pool fee on profits from capital investors
+    ) external;
+
+    function increasePoolBalance(InstanceStore instanceStore, NftId poolNftId, Amount amount, Amount feeAmount) external;
+    function decreasePoolBalance(InstanceStore instanceStore, NftId poolNftId, Amount amount, Amount feeAmount) external;
+
+    //-------- bundle -------------------------------------------------------//
+    function increaseBundleBalance(InstanceStore instanceStore, NftId bundleNftId, Amount amount, Amount feeAmount) external;
+    function decreaseBundleBalance(InstanceStore instanceStore, NftId bundleNftId, Amount amount, Amount feeAmount) external;
+}

package/contracts/shared/IInstanceLinkedComponent.sol

@@ -0,0 +1,46 @@
+// 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 {IComponent} from "../shared/IComponent.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();
+
+    /// @dev registers this component with the registry and instance.
+    /// a component may only be linked once
+    /// only initial component owner (nft holder) is authorizes to call this function
+    function register() external;
+
+    /// @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 defines the instance to which this component is linked to
+    function getInstance() external view returns (IInstance instance);
+
+    /// @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);
+
+}