@etherisc/gif-next 0.0.2-e9148e0-933 → 0.0.2-e91c6be-472

package/contracts/shared/ComponentServiceManager.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ComponentService} from "./ComponentService.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
+
+contract ComponentServiceManager is ProxyManager {
+
+    ComponentService private _componentService;
+
+    /// @dev initializes proxy manager with service implementation 
+    constructor(
+        address authority, 
+        address registry,
+        bytes32 salt
+    )
+    {
+        ComponentService svc = new ComponentService();
+        bytes memory data = abi.encode(registry, authority);
+        IVersionable versionable = initialize(
+            registry,
+            address(svc), 
+            data,
+            salt);
+
+        _componentService = ComponentService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getComponentService()
+        external
+        view
+        returns (ComponentService)
+    {
+        return _componentService;
+    }
+}

package/contracts/shared/ComponentVerifyingService.sol

@@ -0,0 +1,128 @@
+// 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, 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);
+
+    /// @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 objectInfo, 
+            IInstance instance
+        )
+    {
+        componentNftId = getRegistry().getNftIdForAddress(msg.sender);
+        (objectInfo, 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);
+            }
+        }
+
+        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) {
+            if (instance.getInstanceAdmin().isTargetLocked(info.objectAddress)) {
+                revert ErrorComponentVerifyingServiceComponentIsLocked(componentNftId);
+            }
+        }
+    }
+
+
+    function _getInstanceForComponent(IRegistry registry, NftId productNftId)
+        internal
+        view
+        returns (IInstance instance)
+    {
+        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().getObjectInfo(componentNftId).parentNftId;
+    }
+
+
+    /// @dev returns an IInstance contract reference for the specified instance nft id
+    function _getInstance(IRegistry registry, NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            registry.getObjectAddress(instanceNftId));
+    }
+}

package/contracts/shared/ContractLib.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+
+import {IPolicyHolder} from "./IPolicyHolder.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+
+library ContractLib {
+
+    function isPolicyHolder(address target) external view returns (bool) {
+        return ERC165Checker.supportsInterface(target, type(IPolicyHolder).interfaceId);
+    }
+
+
+    function isAccessManaged(address target) external view returns (bool) {
+        if (!isContract(target)) {
+            return false;
+        }
+
+        (bool success, ) = target.staticcall(
+            abi.encodeWithSelector(
+                IAccessManaged.authority.selector));
+
+        return success;
+    }
+
+
+    function 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);
+    }
+}

package/contracts/shared/IComponent.sol

@@ -0,0 +1,67 @@
+// 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 ErrorComponentProductNftIdZero();
+    error ErrorComponentProductNftIdNonzero();
+    error ErrorComponentNameLengthZero();
+
+    error ErrorComponentNotChainNft(address caller);
+
+    error ErrorComponentTokenAddressNonzero();
+    error ErrorComponentTokenAddressZero();
+    error ErrorComponentWalletAddressZero();
+    error ErrorComponentWalletAddressIsSameAsCurrent();
+    error ErrorComponentWalletNotComponent();
+
+    event LogComponentWalletAddressChanged(address oldWallet, address newWallet);
+    event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
+    event LogComponentTokenHandlerApproved(address tokenHandler, address token, Amount limit, bool isMaxAmount);
+
+    /// @dev Approves token hanlder to spend up to the specified amount of tokens.
+    /// Reverts if component wallet is not token handler itself.
+    /// Only component owner (nft holder) is authorizes to call this function.
+    function approveTokenHandler(IERC20Metadata token, Amount spendingLimitAmount) 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,130 @@
+// 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 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 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();
+
+    error ErrorComponentServiceWithdrawAmountIsZero();
+    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);
+    event LogComponentServicePoolFeesUpdated(NftId poolNftId);
+    event LogComponentServiceUpdateFee(
+        NftId nftId, 
+        string feeName, 
+        UFixed previousFractionalFee, 
+        uint256 previousFixedFee,
+        UFixed newFractionalFee, 
+        uint256 newFixedFee
+    );
+
+    //-------- component ----------------------------------------------------//
+
+    /// @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 Approves the staking token handler.
+    /// Reverts if the staking token handler wallet is not the token handler itself.
+    function approveStakingTokenHandler(IERC20Metadata token, Amount amount) external;
+
+    /// @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;
+
+    /// @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 specified product component for the instance (sender)
+    function registerProduct(address product) 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 -------------------------------------------------//
+
+    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;
+
+    //-------- pool ---------------------------------------------------------//
+
+    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,41 @@
+// 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 {IInstance} from "../instance/IInstance.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+
+/// @dev component base class
+/// component examples are product, distribution, pool and oracle
+interface IInstanceLinkedComponent is 
+    IComponent
+{
+    error ErrorInstanceLinkedComponentTypeMismatch(ObjectType requiredType, ObjectType objectType);
+    error ErrorInstanceLinkedComponentNotProduct(NftId nftId, ObjectType objectType);
+
+    /// @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 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);
+
+    /// @dev returns the initial component authorization specification.
+    function getAuthorization() external view returns (IAuthorization authorization);
+
+}

package/contracts/{instance/base → shared}/IKeyValueStore.sol

@@ -1,17 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
-import {Key32, KeyId} from "../../types/Key32.sol";
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId} from "../../types/StateId.sol";
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../type/Blocknumber.sol";
+import {Key32, KeyId} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId} from "../type/StateId.sol";
 
 import {ILifecycle} from "./ILifecycle.sol";
 
-// TODO remove - internal only?
 interface IKeyValueStore is ILifecycle {
 
+    error ErrorKeyValueStoreTypeUndefined(ObjectType objectType);
+    error ErrorKeyValueStoreAlreadyCreated(Key32 key, ObjectType objectType);
+    error ErrorKeyValueStoreNoLifecycle(ObjectType objectType);
+    error ErrorKeyValueStoreStateZero(Key32 key);
+    error ErrorKeyValueStoreNotExisting(Key32 key);
+
+    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
+    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+
     struct Value {
         Metadata metadata;
         bytes data;
@@ -24,15 +33,11 @@ interface IKeyValueStore is ILifecycle {
         // eg account outside gif objects that initiated the tx
         // implies the caller needs to be propagated through all calls up to key values store itself
         // to always have the instance address there doesn't seem to make sense
-        address updatedBy;
+        // address updatedBy;
         Blocknumber updatedIn;
         Blocknumber createdIn;
     }
 
-    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
-    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
-    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
-
     // generic state changing functions
     // function create(Key32 key, bytes memory data) external;
     // function update(Key32 key, bytes memory data, StateId state) external;

package/contracts/{instance/base → shared}/ILifecycle.sol

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId} from "../../types/StateId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId} from "../type/StateId.sol";
 
 interface ILifecycle {
 
-    error ErrorNoLifecycle(NftId nftId, 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

@@ -1,22 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
-interface INftOwnable {
-    error ErrorNotOwner(address account);
+import {IRegistryLinked} from "./IRegistryLinked.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 
-    error ErrorAlreadyLinked(address registry, NftId nftId);
-    error ErrorRegistryAlreadyInitialized(address registry);
-    error ErrorRegistryNotInitialized();
-    error ErrorRegistryAddressZero();
-    error ErrorNotRegistry(address registryAddress);
-    error ErrorContractNotRegistered(address contractAddress);
+interface INftOwnable is
+    IERC165,
+    IRegistryLinked
+{
+    error ErrorNftOwnableInitialOwnerZero();
+    error ErrorNftOwnableNotOwner(address account);
+    error ErrorNftOwnableInvalidType(NftId nftId, ObjectType expectedObjectType);
 
-    function linkToRegisteredNftId() external;
+    error ErrorNftOwnableAlreadyLinked(NftId nftId);
+    error ErrorNftOwnableContractNotRegistered(address contractAddress);
+
+    function linkToRegisteredNftId() external returns (NftId);
 
-    function getRegistry() external view returns (IRegistry);
     function getNftId() external view returns (NftId);
     function getOwner() external view returns (address);
 }

package/contracts/shared/IPolicyHolder.sol

@@ -0,0 +1,35 @@
+// 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";
+import {Timestamp} from "../type/Timestamp.sol";
+
+/// @dev Generic interface for contracts that need to hold policies and receive payouts.
+/// The framework notifies policy holder contracts for policy creation/expiry, claim confirmation and payout execution
+interface IPolicyHolder is
+    IERC165,
+    IERC721Receiver,
+    IRegistryLinked
+{
+
+    /// @dev Callback function that will be called after successful policy activation.
+    /// Active policies may open claims under the activated policy.
+    function policyActivated(NftId policyNftId, Timestamp activatedAt) external;
+
+    /// @dev Callback function to indicate the specified policy has expired.
+    /// expired policies no longer accept new claims.
+    function policyExpired(NftId policyNftId, Timestamp expiredAt) external;
+
+    /// @dev Callback function to notify the confirmation of the specified claim.
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external;
+
+    /// @dev Callback function to notify the successful payout.
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary) external;
+}

package/contracts/shared/IRegisterable.sol

@@ -1,17 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC165} from "@openzeppelin/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 {VersionPart} from "../type/Version.sol";
 
-interface IRegisterable is IERC165, INftOwnable {
+/// @title IRegisterable
+/// @dev Marks contracts that are intended to be registered in the registry.
+/// 
+interface IRegisterable is
+    INftOwnable
+{
+    /// @dev retuns the GIF release version for this contract.
+    /// This 
+    function getRelease() external pure returns (VersionPart release);
 
+    /// @dev retuns the object info relevant for registering for this contract 
+    /// IMPORTANT information returned by this function may only be used
+    /// before the contract is registered in the registry.
+    /// Once registered this information MUST only be accessed via the registry.
     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);
+}