@etherisc/gif-next 0.0.2-e987ccf-894 → 0.0.2-e9c25ee-730

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(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
-            data);
+            data,
+            salt);
 
         _componentService = ComponentService(address(versionable));
     }

package/contracts/shared/ComponentVerifyingService.sol

@@ -5,14 +5,13 @@ 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 {ObjectType, COMPONENT, DISTRIBUTION, ORACLE, POOL, PRODUCT, STAKING} 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);
 
@@ -28,12 +27,12 @@ abstract contract ComponentVerifyingService is
         view
         returns(
             NftId componentNftId,
-            IRegistry.ObjectInfo memory componentInfo, 
+            IRegistry.ObjectInfo memory objectInfo, 
             IInstance instance
         )
     {
         componentNftId = getRegistry().getNftIdForAddress(msg.sender);
-        (componentInfo, instance) = _getAndVerifyComponentInfo(
+        (objectInfo, instance) = _getAndVerifyComponentInfo(
             componentNftId, 
             expectedType,
             true); // only active
@@ -83,7 +82,15 @@ abstract contract ComponentVerifyingService is
             }
         }
 
-        instance = _getInstance(info.parentNftId);
+        if (info.objectType == STAKING()) {
+            return (info, instance);
+        }
+        
+        if (info.objectType == PRODUCT()) {
+            instance = _getInstance(registry, info.parentNftId);
+        } else {
+            instance = _getInstanceForComponent(registry, info.parentNftId);
+        }
 
         // ensure component is not locked
         if (onlyActive) {
@@ -94,24 +101,28 @@ abstract contract ComponentVerifyingService is
     }
 
 
-    /// @dev returns the linked product nft id for the specified component
-    function _getProductNftId(
-        InstanceReader instanceReader,
-        NftId componentNftId
-    )
+    function _getInstanceForComponent(IRegistry registry, NftId productNftId)
         internal
-        virtual
         view
-        returns (NftId productNftId)
+        returns (IInstance instance)
     {
-        return instanceReader.getComponentInfo(componentNftId).productNftId;
+        return _getInstance(
+                registry,
+                registry.getObjectInfo(
+                    productNftId).parentNftId);
+    }
+
+
+    /// @dev returns the product nft id from the registry.
+    /// assumes the component nft id is valid and represents a product linked component.
+    function _getProductNftId(NftId componentNftId) internal view returns (NftId productNftId) {
+        productNftId = getRegistry().getParentNftId(componentNftId);
     }
 
 
     /// @dev returns an IInstance contract reference for the specified instance nft id
-    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+    function _getInstance(IRegistry registry, NftId instanceNftId) internal view returns (IInstance) {
         return IInstance(
-            getRegistry().getObjectInfo(
-                instanceNftId).objectAddress);
+            registry.getObjectAddress(instanceNftId));
     }
 }

package/contracts/shared/ContractLib.sol

@@ -0,0 +1,292 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+// import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
+import {IPolicyHolder} from "../shared/IPolicyHolder.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IService} from "../shared/IService.sol";
+
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, PRODUCT, DISTRIBUTION, ORACLE, POOL, STAKING} from "../type/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
+
+interface ITargetHelper {
+    function isTargetLocked(address target) external view returns (bool);
+}
+
+interface IInstanceAdminHelper {
+    function getInstanceAdmin() external view returns (ITargetHelper);
+}
+
+interface ITokenRegistryHelper {
+    function isActive(uint256 chainId, address token, VersionPart release) external view returns (bool);
+}
+
+library ContractLib {
+
+    error ErrorContractLibNotRegistered(address target);
+    error ErrorContractLibNotComponent(NftId componentNftId, ObjectType objectType);
+    error ErrorContractLibNotStaking(NftId componentNftId, ObjectType objectType);
+    error ErrorContractLibComponentTypeMismatch(NftId componentNftId, ObjectType expectedType, ObjectType actualType);
+    error ErrorContractLibComponentInactive(NftId componentNftId);
+
+    function getAndVerifyComponent(
+        IRegistry registry, 
+        address target,
+        ObjectType expectedType,
+        bool onlyActive
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info, 
+            address instance
+        )
+    {
+        // check target is component
+        info = _getObjectInfo(registry, target);
+        if(info.objectType != expectedType) {
+            revert ErrorContractLibComponentTypeMismatch(
+                info.nftId,
+                expectedType,
+                info.objectType);
+        }
+
+        // get instance and check component is active
+        instance = _getInstance(registry, info);
+        _checkComponentActive(instance, target, info.nftId, onlyActive);
+    }
+
+
+    function getInfoAndInstance(
+        IRegistry registry,
+        NftId componentNftId,
+        bool onlyActive
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info, 
+            address instance
+        )
+    {
+        info = registry.getObjectInfo(componentNftId);
+        instance = _getInstance(registry, info);
+        _checkComponentActive(instance, info.objectAddress, info.nftId, onlyActive);
+    }
+
+
+    function getAndVerifyStaking(
+        IRegistry registry, 
+        address target
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info
+        )
+    {
+        // check target is component
+        info = _getObjectInfo(registry, target);
+        if(info.objectType != STAKING()) {
+            revert ErrorContractLibNotStaking(
+                info.nftId,
+                info.objectType);
+        }
+    }
+
+
+    function getAndVerifyAnyComponent(
+        IRegistry registry, 
+        address target,
+        bool onlyActive
+    )
+        external
+        view
+        returns (
+            IRegistry.ObjectInfo memory info, 
+            address instance
+        )
+    {
+        // check target is component
+        info = _getObjectInfo(registry, target);
+        if(!(info.objectType == PRODUCT()
+            || info.objectType == POOL()
+            || info.objectType == DISTRIBUTION()
+            || info.objectType == ORACLE())
+        ) {
+            revert ErrorContractLibNotComponent(
+                info.nftId,
+                info.objectType);
+        }
+
+        // get instance and check component is active
+        instance = _getInstance(registry, info);
+        _checkComponentActive(instance, target, info.nftId, onlyActive);
+    }
+
+
+    function getInstanceForComponent(
+        IRegistry registry, 
+        NftId componentNftId
+    )
+        public
+        view
+        returns (address instance)
+    {
+        NftId productNftId = registry.getParentNftId(componentNftId);
+        NftId instanceNftId = registry.getParentNftId(productNftId);
+        return registry.getObjectInfo(instanceNftId).objectAddress;
+    }
+
+
+    function isActiveToken(
+        address tokenRegistryAddress,
+        address token,
+        uint256 chainId, 
+        VersionPart release
+    )
+        external 
+        view 
+        returns (bool)
+    {
+        return ITokenRegistryHelper(
+            tokenRegistryAddress).isActive(
+                chainId, token, release);
+    }
+
+    function isPolicyHolder(address target) external view returns (bool) {
+        return ERC165Checker.supportsInterface(target, type(IPolicyHolder).interfaceId);
+    }
+
+
+    function isAuthority(address authority) public view returns (bool) {
+        if (!isContract(authority)) {
+            return false;
+        }
+
+        return supportsInterface(authority, type(IAccessManager).interfaceId);
+    }
+
+
+    function isAccessManaged(address target)
+        public
+        view
+        returns (bool)
+    {
+        if (!isContract(target)) {
+            return false;
+        }
+
+        (bool success, ) = target.staticcall(
+            abi.encodeWithSelector(
+                IAccessManaged.authority.selector));
+
+        return success;
+    }
+
+
+    function isRegistered(address registry, address caller, ObjectType expectedType) public view returns (bool) {
+        NftId nftId = IRegistry(registry).getNftIdForAddress(caller);
+        if (nftId.eqz()) {
+            return false;
+        }
+
+        return IRegistry(registry).getObjectInfo(nftId).objectType == expectedType;
+    }
+
+
+    function isService(address service) public view returns (bool) {
+        if (!isContract(service)) {
+            return false;
+        }
+
+        return supportsInterface(service, type(IService).interfaceId);
+    }
+
+
+    function isRegistry(address registry) public view returns (bool) {
+        if (!isContract(registry)) {
+            return false;
+        }
+
+        return supportsInterface(registry, type(IRegistry).interfaceId);
+    }
+
+
+    function isContract(address target) public view returns (bool) {
+        if (target == address(0)) {
+            return false;
+        }
+
+        uint256 size;
+        assembly {
+            size := extcodesize(target)
+        }
+        return size > 0;
+    }
+
+    function supportsInterface(address target, bytes4 interfaceId)  public view returns (bool) {
+        return ERC165Checker.supportsInterface(target, interfaceId);
+    }
+
+
+    function _checkComponentActive(
+        address instance, 
+        address target, 
+        NftId componentNftId, 
+        bool onlyActive
+    )
+        internal
+        view
+    {
+        if (onlyActive) {
+            if (IInstanceAdminHelper(
+                instance).getInstanceAdmin().isTargetLocked(
+                    target)
+            ) {
+                revert ErrorContractLibComponentInactive(componentNftId);
+            }
+        }
+    }
+
+
+    function _getInstance(
+        IRegistry registry,
+        IRegistry.ObjectInfo memory info
+    )
+        internal
+        view
+        returns (address instance)
+    {
+        if (info.objectType == PRODUCT()) {
+            return registry.getObjectAddress(
+                info.parentNftId);
+        } 
+        
+        return registry.getObjectAddress(
+                registry.getObjectInfo(
+                    info.parentNftId).parentNftId);
+    }
+
+
+    function _getObjectInfo(
+        IRegistry registry, 
+        address target
+    )
+        internal
+        view
+        returns (IRegistry.ObjectInfo memory info)
+    {
+        NftId componentNftId = registry.getNftIdForAddress(target);
+        if (componentNftId.eqz()) {
+            revert ErrorContractLibNotRegistered(target);
+        }
+
+        info = registry.getObjectInfo(componentNftId);
+    }
+}

package/contracts/shared/IComponent.sol

@@ -1,7 +1,6 @@
 // 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";
@@ -13,33 +12,22 @@ 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 ErrorComponentProductNftIdZero();
+    error ErrorComponentProductNftIdNonzero();
+    error ErrorComponentNameLengthZero();
+
     error ErrorComponentNotChainNft(address caller);
 
-    error ErrorComponentTokenAddressZero();
-    error ErrorComponentNameLengthZero();
     error ErrorComponentWalletAddressZero();
     error ErrorComponentWalletAddressIsSameAsCurrent();
     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 to the tokenhandler of the component that 
-    /// covers the current component balance must exist
-    function setWallet(address walletAddress) external;
+    event LogComponentTokenHandlerApproved(address tokenHandler, address token, Amount limit, bool isMaxAmount);
 
     /// @dev returns the name of this component
     /// to successfully register the component with an instance the name MUST be unique in the linked instance

package/contracts/shared/IComponentService.sol

@@ -1,19 +1,44 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 import {Amount} from "../type/Amount.sol";
 import {Fee} from "../type/Fee.sol";
-import {InstanceStore} from "../instance/InstanceStore.sol";
 import {IService} from "../shared/IService.sol";
 import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 import {UFixed} from "../type/UFixed.sol";
+import {VersionPart} from "../type/Version.sol";
 
 /// @dev component base class
 /// component examples are staking, product, distribution, pool and oracle
 interface IComponentService is 
     IService
 {
+    error ErrorComponentServiceTokenInvalid(address token);
+
+    error ErrorComponentServiceNotInstanceLinkedComponent(address component);
+    error ErrorComponentServiceSenderNotRegistered(address sender);
+    error ErrorComponentServiceNotComponent(address component);
+    error ErrorComponentServiceTypeNotSupported(address component, ObjectType invalidType);
+    error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
+    error ErrorComponentServiceAlreadyRegistered(address component);
+    error ErrorComponentServiceReleaseMismatch(address component, VersionPart componentRelease, VersionPart parentRelease);
+    error ErrorComponentServiceSenderNotComponentParent(NftId senderNftId, NftId compnentParentNftId);
+    error ErrorComponentServiceParentNotInstance(NftId nftId, ObjectType objectType);
+    error ErrorComponentServiceParentNotProduct(NftId nftId, ObjectType objectType);
+
+    error ErrorComponentServiceNotRegistered(address instanceAddress);
+    error ErrorComponentServiceNotInstance(address instanceAddress, ObjectType objectType);
+    error ErrorComponentServiceInstanceVersionMismatch(address instanceAddress, VersionPart instanceVersion);
+    
+    error ErrorProductServiceNoDistributionExpected(NftId productNftId);
+    error ErrorProductServiceDistributionAlreadyRegistered(NftId productNftId, NftId distributionNftId);
+    error ErrorProductServiceNoOraclesExpected(NftId productNftId);
+    error ErrorProductServiceOraclesAlreadyRegistered(NftId productNftId, uint8 expectedOracles);
+    error ErrorProductServicePoolAlreadyRegistered(NftId productNftId, NftId poolNftId);
+
     error ErrorComponentServiceNewWalletAddressZero();
     error ErrorComponentServiceWalletAddressZero();
     error ErrorComponentServiceWalletAddressIsSameAsCurrent();
@@ -22,7 +47,9 @@ interface IComponentService is
     error ErrorComponentServiceWithdrawAmountExceedsLimit(Amount withdrawnAmount, Amount withdrawLimit);
     error ErrorComponentServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
 
+    event LogComponentServiceRegistered(NftId instanceNftId, NftId componentNftId, ObjectType componentType, address component, address token, address initialOwner); 
     event LogComponentServiceWalletAddressChanged(NftId componentNftId, address currentWallet, address newWallet);
+    event LogComponentServiceWalletTokensTransferred(NftId componentNftId, address currentWallet, address newWallet, uint256 currentBalance);
     event LogComponentServiceComponentFeesWithdrawn(NftId componentNftId, address recipient, address token, Amount withdrawnAmount);
     event LogComponentServiceProductFeesUpdated(NftId productNftId);
     event LogComponentServiceDistributionFeesUpdated(NftId distributionNftId);
@@ -31,78 +58,55 @@ interface IComponentService is
         NftId nftId, 
         string feeName, 
         UFixed previousFractionalFee, 
-        uint256 previousFixedFee,
+        Amount previousFixedFee,
         UFixed newFractionalFee, 
-        uint256 newFixedFee
+        Amount newFixedFee
     );
-
+    
     //-------- component ----------------------------------------------------//
 
-    /// @dev sets the components associated wallet address
-    function setWallet(address newWallet) external;
+    /// @dev Approves the callers token handler to spend up to the specified amount of tokens.
+    /// Reverts if the component's token handler wallet is not the token handler itself.
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external;
 
-    /// @dev locks the component associated with the caller
-    function lock() external;
+    /// @dev Sets the components associated wallet address.
+    /// To set the wallet to the token handler contract, use address(0) as the new wallet adress.
+    function setWallet(address newWallet) external;
 
-    /// @dev unlocks the component associated with the caller
-    function unlock() external;
+    /// @dev Locks/Unlocks the calling component.
+    function setLocked(bool locked) external;
 
     /// @dev Withdraw fees from the distribution component. Only component owner is allowed to withdraw fees.
     /// @param withdrawAmount the amount to withdraw
     /// @return withdrawnAmount the amount that was actually withdrawn
     function withdrawFees(Amount withdrawAmount) external returns (Amount withdrawnAmount);
 
+    /// @dev Registers the provided component with the product (sender)
+    function registerComponent(address component) external returns (NftId componentNftId);
+
     //-------- product ------------------------------------------------------//
 
-    /// @dev registers the sending component as a product component
-    function registerProduct() external;
+    /// @dev Registers the specified product component for the instance (sender)
+    function registerProduct(address product, address token) external returns (NftId productNftId);
 
     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;
-
-    //-------- distributor --------------------------------------------------//
-    function increaseDistributorBalance(InstanceStore instanceStore, NftId distributorNftId, Amount amount, Amount feeAmount) external;
-    function decreaseDistributorBalance(InstanceStore instanceStore, NftId distributorNftId, 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

@@ -1,42 +1,20 @@
 // 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 {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();
-
-    /// @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;
+    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
@@ -49,8 +27,4 @@ interface IInstanceLinkedComponent is
     /// @dev returns the initial component authorization specification.
     function getAuthorization() external view returns (IAuthorization authorization);
 
-    /// @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);
-
 }

package/contracts/shared/ILifecycle.sol

@@ -6,8 +6,10 @@ import {StateId} from "../type/StateId.sol";
 
 interface ILifecycle {
 
-    error ErrorNoLifecycle(ObjectType objectType);
+    error ErrorNoLifecycle(address contractAddress, ObjectType objectType);
+    error ErrorFromStateMissmatch(address contractAddress, ObjectType objectType, StateId actual, StateId required);
     error ErrorInvalidStateTransition(
+        address contractAddress,
         ObjectType objectType,
         StateId fromStateId,
         StateId toStateId

package/contracts/shared/INftOwnable.sol

@@ -5,6 +5,7 @@ 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,
@@ -12,6 +13,7 @@ interface INftOwnable is
 {
     error ErrorNftOwnableInitialOwnerZero();
     error ErrorNftOwnableNotOwner(address account);
+    error ErrorNftOwnableInvalidType(NftId nftId, ObjectType expectedObjectType);
 
     error ErrorNftOwnableAlreadyLinked(NftId nftId);
     error ErrorNftOwnableContractNotRegistered(address contractAddress);