@etherisc/gif-next 0.0.2-bdd64e2-180 → 0.0.2-be78639-672

package/contracts/instance/InstanceServiceManager.sol

@@ -1,47 +1,30 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Instance} from "./Instance.sol";
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {InstanceService} from "./InstanceService.sol";
-import {Registry} from "../registry/Registry.sol";
-import {RegistryService} from "../registry/RegistryService.sol";
-import {VersionLib} from "../types/Version.sol";
 
 contract InstanceServiceManager is ProxyManager {
 
     InstanceService private _instanceService;
 
-    /// @dev initializes proxy manager with instance service implementation and deploys instance
+    /// @dev initializes proxy manager with instance service implementation
     constructor(
-        address registryAddress
-    )
-        ProxyManager()
+        address authority, 
+        address registry,
+        bytes32 salt
+    ) 
     {
-        InstanceService instSrv = new InstanceService();
-        // bytes memory initCode = type(InstanceService).creationCode;
-        bytes memory data = abi.encode(registryAddress, address(this));
-        IVersionable versionable = deploy(
-            address(instSrv), 
-            data);
+        InstanceService svc = new InstanceService{salt: salt}();
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
+            address(svc), 
+            data,
+            salt);
 
         _instanceService = InstanceService(address(versionable));
-
-        Registry registry = Registry(registryAddress);
-        address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
-        RegistryService registryService = RegistryService(registryServiceAddress);
-
-        registryService.registerService(_instanceService);
-        // RegistryService registryService = _instanceService.getRegistryService();
-
-        // link ownership of instance service manager ot nft owner of instance service
-        _linkToNftOwnable(
-            address(registryAddress),
-            address(_instanceService));
-
-        // implies that after this constructor call only upgrade functionality is available
-        _isDeployed = true;
     }
 
     //--- view functions ----------------------------------------------------//

package/contracts/instance/InstanceStore.sol

@@ -0,0 +1,323 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+
+import {IBundle} from "./module/IBundle.sol";
+import {IComponents} from "./module/IComponents.sol";
+import {IDistribution} from "./module/IDistribution.sol";
+import {IInstance} from "./IInstance.sol";
+import {IOracle} from "../oracle/IOracle.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {BaseStore} from "./BaseStore.sol";
+import {Blocknumber} from "../type/Blocknumber.sol";
+import {Key32} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {ObjectType, BUNDLE, POOL, COMPONENT, DISTRIBUTOR} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {StateId} from "../type/StateId.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {BalanceStore} from "./base/BalanceStore.sol";
+import {ObjectCounter} from "./base/ObjectCounter.sol";
+import {ObjectLifecycle} from "./base/ObjectLifecycle.sol";
+
+
+contract InstanceStore is
+    AccessManagedUpgradeable, 
+    BalanceStore,
+    ObjectCounter,
+    ObjectLifecycle,
+    BaseStore
+{
+
+    event LogProductStoreComponentInfoCreated(NftId componentNftId, StateId state, address createdby, address txOrigin);
+    event LogProductStoreComponentInfoUpdated(NftId componentNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStorePoolInfoCreated(NftId poolNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStorePoolInfoUpdated(NftId poolNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreDistributorTypeInfoCreated(DistributorType distributorType, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreDistributorTypeInfoUpdated(DistributorType distributorType, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreDistributorInfoCreated(NftId distributorNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreDistributorInfoUpdated(NftId distributorNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreReferralInfoCreated(ReferralId referralId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreReferralInfoUpdated(ReferralId referralId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreBundleInfoCreated(NftId bundleNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreBundleInfoUpdated(NftId bundleNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreRequestInfoCreated(RequestId requestId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreRequestInfoUpdated(RequestId requestId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+
+
+    mapping(Key32 => IComponents.ComponentInfo) private _components;
+    mapping(Key32 => IComponents.PoolInfo) private _pools;
+    mapping(Key32 => IDistribution.DistributorTypeInfo) private _distributorTypes;
+    mapping(Key32 => IDistribution.DistributorInfo) private _distributors;
+    mapping(Key32 => IDistribution.ReferralInfo) private _referrals;
+    mapping(Key32 => IBundle.BundleInfo) private _bundles;
+    mapping(Key32 => IOracle.RequestInfo) private _requests;
+
+
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize()
+        public 
+        initializer()
+    {
+        address instance = msg.sender;
+        address authority = IInstance(instance).authority();
+
+        __AccessManaged_init(authority);
+        // double initialization, safe
+        _initializeLifecycle();
+    }
+
+    //--- Component ---------------------------------------------------------//
+
+    function createComponent(
+        NftId componentNftId, 
+        IComponents.ComponentInfo memory componentInfo
+    )
+        external 
+        restricted()
+    {
+        _registerBalanceTarget(componentNftId);
+        // _create(_toNftKey32(componentNftId, COMPONENT()), abi.encode(componentInfo));
+        Key32 key = _toNftKey32(componentNftId, COMPONENT());
+        _createMetadata(key);
+        _components[key] = componentInfo;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreComponentInfoCreated(componentNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateComponent(
+        NftId componentNftId, 
+        IComponents.ComponentInfo memory componentInfo,
+        StateId newState
+    )
+        external 
+        restricted()
+    {
+        // _update(_toNftKey32(componentNftId, COMPONENT()), abi.encode(componentInfo), newState);
+        Key32 key = _toNftKey32(componentNftId, COMPONENT());
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        _components[key] = componentInfo;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreComponentInfoUpdated(componentNftId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function getComponentInfo(NftId componentNftId) external view returns (IComponents.ComponentInfo memory componentInfo) {
+        return _components[_toNftKey32(componentNftId, COMPONENT())];
+    }
+
+    //--- Pool --------------------------------------------------------------//
+
+    function createPool(
+        NftId poolNftId, 
+        IComponents.PoolInfo memory info
+    )
+        external 
+        restricted()
+    {
+        Key32 key = _toNftKey32(poolNftId, POOL());
+        _createMetadata(key);
+        _pools[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePoolInfoCreated(poolNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updatePool(NftId poolNftId, IComponents.PoolInfo memory info, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(poolNftId, POOL());
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        _pools[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePoolInfoUpdated(poolNftId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function getPoolInfo(NftId poolNftId) external view returns (IComponents.PoolInfo memory info) {
+        return _pools[_toNftKey32(poolNftId, POOL())];
+    }
+
+    //--- DistributorType ---------------------------------------------------//
+    function createDistributorType(DistributorType distributorType, IDistribution.DistributorTypeInfo memory info) external restricted() {
+        Key32 key = distributorType.toKey32();
+        _createMetadata(key);
+        _distributorTypes[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreDistributorTypeInfoCreated(distributorType, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateDistributorType(DistributorType distributorType, IDistribution.DistributorTypeInfo memory info, StateId newState) external restricted() {
+        Key32 key = distributorType.toKey32();
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        _distributorTypes[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreDistributorTypeInfoUpdated(distributorType, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function updateDistributorTypeState(DistributorType distributorType, StateId newState) external restricted() {
+        Key32 key = distributorType.toKey32();
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreDistributorTypeInfoUpdated(distributorType, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function getDistributorTypeInfo(DistributorType distributorType) external view returns (IDistribution.DistributorTypeInfo memory info) {
+        return _distributorTypes[distributorType.toKey32()];
+    }
+
+    //--- Distributor -------------------------------------------------------//
+    function createDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info) external restricted() {
+        _registerBalanceTarget(distributorNftId);
+        Key32 key = _toNftKey32(distributorNftId, DISTRIBUTOR());
+        _createMetadata(key);
+        _distributors[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreDistributorInfoCreated(distributorNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(distributorNftId, DISTRIBUTOR());
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        _distributors[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreDistributorInfoUpdated(distributorNftId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function updateDistributorState(NftId distributorNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(distributorNftId, DISTRIBUTOR());
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreDistributorInfoUpdated(distributorNftId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function getDistributorInfo(NftId distributorNftId) external view returns (IDistribution.DistributorInfo memory info) {
+        return _distributors[_toNftKey32(distributorNftId, DISTRIBUTOR())];
+    }
+
+    //--- Referral ----------------------------------------------------------//
+    function createReferral(ReferralId referralId, IDistribution.ReferralInfo memory referralInfo) external restricted() {
+        Key32 key = referralId.toKey32();
+        _createMetadata(key);
+        _referrals[key] = referralInfo;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreReferralInfoCreated(referralId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateReferral(ReferralId referralId, IDistribution.ReferralInfo memory referralInfo, StateId newState) external restricted() {
+        Key32 key = referralId.toKey32();
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        _referrals[key] = referralInfo;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreReferralInfoUpdated(referralId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function updateReferralState(ReferralId referralId, StateId newState) external restricted() {
+        Key32 key = referralId.toKey32();
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreReferralInfoUpdated(referralId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function getReferralInfo(ReferralId referralId) external view returns (IDistribution.ReferralInfo memory referralInfo) {
+        return _referrals[referralId.toKey32()];
+    }
+
+    //--- Bundle ------------------------------------------------------------//
+    function createBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle) external restricted() {
+        _registerBalanceTarget(bundleNftId);
+        Key32 key = _toNftKey32(bundleNftId, BUNDLE());
+        _createMetadata(key);
+        _bundles[key] = bundle;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreBundleInfoCreated(bundleNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(bundleNftId, BUNDLE());
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        _bundles[key] = bundle;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreBundleInfoUpdated(bundleNftId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function updateBundleState(NftId bundleNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(bundleNftId, BUNDLE());
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreBundleInfoUpdated(bundleNftId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function getBundleInfo(NftId bundleNftId) external view returns (IBundle.BundleInfo memory bundle) {
+        return _bundles[_toNftKey32(bundleNftId, BUNDLE())];
+    }
+    
+    //--- Request -----------------------------------------------------------//
+
+    function createRequest(IOracle.RequestInfo memory request) external restricted() returns (RequestId requestId) {
+        requestId = _createNextRequestId();
+        Key32 key = requestId.toKey32();
+        _createMetadata(key);
+        _requests[key] = request;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRequestInfoCreated(requestId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateRequest(RequestId requestId, IOracle.RequestInfo memory request, StateId newState) external restricted() {
+        Key32 key = requestId.toKey32();
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        _requests[key] = request;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRequestInfoUpdated(requestId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function updateRequestState(RequestId requestId, StateId newState) external restricted() {
+        Key32 key = requestId.toKey32();
+        (Blocknumber updatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRequestInfoUpdated(requestId, oldState, newState, msg.sender, tx.origin, updatedIn);
+    }
+
+    function getRequestInfo(RequestId requestId) external view returns (IOracle.RequestInfo memory request) {
+        return _requests[requestId.toKey32()];
+    }
+
+    //--- balance and fee management functions ------------------------------//
+
+    function increaseBalance(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _increaseBalance(targetNftId, amount);
+    }
+
+    function decreaseBalance(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _decreaseBalance(targetNftId, amount);
+    }
+
+    function increaseFees(NftId targetNftId, Amount amount) external restricted() returns (Amount newFeeBalance) {
+        return _increaseFees(targetNftId, amount);
+    }
+
+    function decreaseFees(NftId targetNftId, Amount amount) external restricted() returns (Amount newFeeBalance) {
+        return _decreaseFees(targetNftId, amount);
+    }
+
+    function increaseLocked(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _increaseLocked(targetNftId, amount);
+    }
+
+    function decreaseLocked(NftId targetNftId, Amount amount) external restricted() returns (Amount newBalance) {
+        return _decreaseLocked(targetNftId, amount);
+    }
+
+    //--- internal view/pure functions --------------------------------------//
+    function _toNftKey32(NftId nftId, ObjectType objectType) private pure returns (Key32) {
+        return nftId.toKey32(objectType);
+    }
+
+    function _toClaimKey32(NftId policyNftId, ClaimId claimId) private pure returns (Key32) {
+        return claimId.toKey32(policyNftId);
+    }
+
+    function _toPayoutKey32(NftId policyNftId, PayoutId payoutId) private pure returns (Key32) {
+        return payoutId.toKey32(policyNftId);
+    }
+}

package/contracts/instance/ProductStore.sol

@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+
+import {IComponents} from "./module/IComponents.sol";
+import {IInstance} from "./IInstance.sol";
+import {IPolicy} from "./module/IPolicy.sol";
+import {IRisk} from "./module/IRisk.sol";
+
+import {BalanceStore} from "./base/BalanceStore.sol";
+import {BaseStore} from "./BaseStore.sol";
+import {Blocknumber} from "../type/Blocknumber.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {Key32} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectCounter} from "./base/ObjectCounter.sol";
+import {ObjectLifecycle} from "./base/ObjectLifecycle.sol";
+import {ObjectType, FEE, POLICY, PREMIUM, PRODUCT} from "../type/ObjectType.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {StateId, KEEP_STATE} from "../type/StateId.sol";
+
+
+contract ProductStore is
+    AccessManagedUpgradeable, 
+    BalanceStore,
+    BaseStore,
+    ObjectCounter,
+    ObjectLifecycle
+{
+    event LogProductStoreProductInfoCreated(NftId productNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreProductInfoUpdated(NftId productNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreFeeInfoCreated(NftId productNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreFeeInfoUpdated(NftId productNftId, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreRiskInfoCreated(RiskId riskId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreRiskInfoUpdated(RiskId riskId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStorePolicyInfoCreated(NftId policyNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStorePolicyInfoUpdated(NftId policyNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStorePremiumInfoCreated(NftId policyNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStorePremiumInfoUpdated(NftId policyNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreClaimInfoCreated(NftId policyNftId, ClaimId claimId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreClaimInfoUpdated(NftId policyNftId, ClaimId claimId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStorePayoutInfoCreated(NftId policyNftId, PayoutId payoutId, StateId state, address createdBy, address txOrigin);
+    event LogProductStorePayoutInfoUpdated(NftId policyNftId, PayoutId payoutId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+
+    mapping(Key32 key32 => IComponents.ProductInfo) private _products;
+    mapping(Key32 key32 => IComponents.FeeInfo) private _fees;
+    mapping(Key32 key32 => IRisk.RiskInfo) private _risks;
+    mapping(Key32 key32 => IPolicy.PolicyInfo) private _policies;
+    mapping(Key32 key32 => IPolicy.PremiumInfo) private _premiums;
+    mapping(Key32 key32 => IPolicy.ClaimInfo) private _claims;
+    mapping(Key32 key32 => IPolicy.PayoutInfo) private _payouts;
+
+
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize()
+        public 
+        initializer()
+    {
+        address instance = msg.sender;
+        address authority = IInstance(instance).authority();
+
+        __AccessManaged_init(authority);
+        // double initialization, safe
+        _initializeLifecycle();
+    }
+
+
+    //--- Product -----------------------------------------------------------//
+
+    function createProduct(NftId productNftId, IComponents.ProductInfo memory info) external restricted() {
+        Key32 key = _toNftKey32(productNftId, PRODUCT());
+        _createMetadata(key);
+        _products[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreProductInfoCreated(productNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateProduct(NftId productNftId, IComponents.ProductInfo memory info, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(productNftId, PRODUCT());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _products[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreProductInfoUpdated(productNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getProductInfo(NftId productNftId) external view returns (IComponents.ProductInfo memory info) {
+        return _products[_toNftKey32(productNftId, PRODUCT())];
+    }
+
+    //--- Fee -----------------------------------------------------------//
+
+    function createFee(NftId productNftId, IComponents.FeeInfo memory info) external restricted() {
+        Key32 key = _toNftKey32(productNftId, FEE());
+        _createMetadata(key);
+        _fees[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreFeeInfoCreated(productNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    // Fee only has one state, so no change change possible
+    function updateFee(NftId productNftId, IComponents.FeeInfo memory info) external restricted() {
+        Key32 key = _toNftKey32(productNftId, FEE());
+        (Blocknumber lastUpdatedIn,) = _updateState(key, KEEP_STATE());
+        _fees[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreFeeInfoUpdated(productNftId, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getFeeInfo(NftId productNftId) external view returns (IComponents.FeeInfo memory info) {
+        return _fees[_toNftKey32(productNftId, FEE())];
+    }
+
+    //--- Risk --------------------------------------------------------------//
+    function createRisk(RiskId riskId, IRisk.RiskInfo memory info) external restricted() {
+        Key32 key = riskId.toKey32();
+        _createMetadata(key);
+        _risks[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRiskInfoCreated(riskId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateRisk(RiskId riskId, IRisk.RiskInfo memory info, StateId newState) external restricted() {
+        Key32 key = riskId.toKey32();
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _risks[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRiskInfoUpdated(riskId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updateRiskState(RiskId riskId, StateId newState) external restricted() {
+        // _updateState(riskId.toKey32(), newState);
+        Key32 key = riskId.toKey32();
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRiskInfoUpdated(riskId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getRiskInfo(RiskId riskId) external view returns (IRisk.RiskInfo memory info) {
+        return _risks[riskId.toKey32()];
+    }
+
+    //--- Application (Policy) ----------------------------------------------//
+
+    function createApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy) external restricted() {
+        _registerBalanceTarget(applicationNftId);
+        Key32 key = _toNftKey32(applicationNftId, POLICY());
+        _createMetadata(key);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoCreated(applicationNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(applicationNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(applicationNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updateApplicationState(NftId applicationNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(applicationNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(applicationNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    //--- Policy ------------------------------------------------------------//
+
+    function updatePolicy(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updatePolicyClaims(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updatePolicyState(NftId policyNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getPolicyInfo(NftId policyNftId) external view returns (IPolicy.PolicyInfo memory policy) {
+        return _policies[_toNftKey32(policyNftId, POLICY())];
+    }
+
+    //--- Premium (Policy) ----------------------------------------------//
+
+    function createPremium(NftId policyNftId, IPolicy.PremiumInfo memory premium) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, PREMIUM());
+        _createMetadata(key);
+        _premiums[key] = premium;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePremiumInfoCreated(policyNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updatePremiumState(NftId policyNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, PREMIUM());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePremiumInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getPremiumInfo(NftId policyNftId) external view returns (IPolicy.PremiumInfo memory premium) {
+        return _premiums[_toNftKey32(policyNftId, PREMIUM())];
+    }
+
+    //--- Claim -------------------------------------------------------------//
+
+    function createClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim) external restricted() {
+        Key32 key = _toClaimKey32(policyNftId, claimId);
+        _createMetadata(key);
+        _claims[key] = claim;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreClaimInfoCreated(policyNftId, claimId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim, StateId newState) external restricted() {
+        Key32 key = _toClaimKey32(policyNftId, claimId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _claims[key] = claim;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreClaimInfoUpdated(policyNftId, claimId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updateClaimState(NftId policyNftId, ClaimId claimId, StateId newState) external restricted() {
+        Key32 key = _toClaimKey32(policyNftId, claimId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreClaimInfoUpdated(policyNftId, claimId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getClaimInfo(NftId policyNftId, ClaimId claimId) external view returns (IPolicy.ClaimInfo memory claim) {
+        return _claims[_toClaimKey32(policyNftId, claimId)];
+    }
+
+    //--- Payout ------------------------------------------------------------//
+
+    function createPayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout) external restricted() {
+        Key32 key = _toPayoutKey32(policyNftId, payoutId);
+        _createMetadata(key);
+        _payouts[key] = payout;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePayoutInfoCreated(policyNftId, payoutId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updatePayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout, StateId newState) external restricted() {
+        Key32 key = _toPayoutKey32(policyNftId, payoutId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _payouts[key] = payout;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePayoutInfoUpdated(policyNftId, payoutId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updatePayoutState(NftId policyNftId, PayoutId payoutId, StateId newState) external restricted() {
+        Key32 key = _toPayoutKey32(policyNftId, payoutId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePayoutInfoUpdated(policyNftId, payoutId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getPayoutInfo(NftId policyNftId, PayoutId payoutId) external view returns (IPolicy.PayoutInfo memory payout) {
+        return _payouts[_toPayoutKey32(policyNftId, payoutId)];
+    }
+
+    //--- internal view/pure functions --------------------------------------//
+    function _toNftKey32(NftId nftId, ObjectType objectType) private pure returns (Key32) {
+        return nftId.toKey32(objectType);
+    }
+
+    function _toClaimKey32(NftId policyNftId, ClaimId claimId) private pure returns (Key32) {
+        return claimId.toKey32(policyNftId);
+    }
+
+    function _toPayoutKey32(NftId policyNftId, PayoutId payoutId) private pure returns (Key32) {
+        return payoutId.toKey32(policyNftId);
+    }
+}