@etherisc/gif-next 0.0.2-d16f92c-416 → 0.0.2-d18e1c5-511

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);
+    }
+}

package/contracts/instance/RiskSet.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Key32} from "../type/Key32.sol";
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectSet} from "./base/ObjectSet.sol";
+import {ObjectSetHelperLib} from "./base/ObjectSetHelperLib.sol";
+import {RiskIdLib, RiskId} from "../type/RiskId.sol";
+
+/// @dev RiskSet manages the risks and its active policies per product.
+contract RiskSet is
+    ObjectSet
+{
+
+    event LogRiskSetPolicyLinked(RiskId riskId, NftId policyNftId);
+    event LogRiskSetPolicyUnlinked(RiskId riskId, NftId policyNftId);
+
+    event LogRiskSetRiskAdded(NftId productNftId, RiskId riskId);
+    event LogRiskSetRiskActive(NftId poolNftId,  RiskId riskId);
+    event LogRiskSetRiskPaused(NftId poolNftId,  RiskId riskId);
+
+    error ErrorRiskSetRiskLocked(RiskId riskId, NftId policyNftId); 
+    error ErrorRiskSetRiskUnknown(RiskId riskId);
+    error ErrorRiskSetRiskNotRegistered(RiskId riskId);
+
+    mapping(RiskId riskId => LibNftIdSet.Set policies) internal _activePolicies;
+
+    /// @dev links a policy to its bundle
+    function linkPolicy(NftId productNftId, RiskId riskId, NftId policyNftId) external restricted() {
+
+        // ensure risk is active (in active set) and registered with this instance
+        if (!_isActive(productNftId, riskId.toKey32())) {
+            revert ErrorRiskSetRiskLocked(riskId, policyNftId);
+        }
+
+        LibNftIdSet.add(_activePolicies[riskId], policyNftId);
+        emit LogRiskSetPolicyLinked(riskId, policyNftId);
+    }
+
+    /// @dev Unlinks a policy from its risk.
+    function unlinkPolicy(NftId productNftId, RiskId riskId, NftId policyNftId) external restricted() {
+
+        // ensure risk is registered with this instance
+        if (!_contains(productNftId, riskId.toKey32())) {
+            revert ErrorRiskSetRiskUnknown(riskId);
+        }
+
+        LibNftIdSet.remove(_activePolicies[riskId], policyNftId);
+        emit LogRiskSetPolicyUnlinked(riskId, policyNftId);
+    }
+
+    /// @dev add a new risk to a product registered with this instance
+    // the corresponding product is fetched via instance reader
+    function add(RiskId riskId) external restricted() {
+        NftId productNftId = ObjectSetHelperLib.getProductNftId(_instanceAddress, riskId);
+
+        // ensure product is registered with instance
+        if(productNftId.eqz()) {
+            revert ErrorRiskSetRiskNotRegistered(riskId);
+        }
+
+        _add(productNftId, riskId.toKey32());
+        emit LogRiskSetRiskAdded(productNftId, riskId);
+    }
+
+    /// @dev Applications linked to active risks may be underwritten
+    function activate(RiskId riskId) external restricted() {
+        NftId productNftId = ObjectSetHelperLib.getProductNftId(_instanceAddress, riskId);
+        _activate(productNftId, riskId.toKey32());
+        emit LogRiskSetRiskActive(productNftId, riskId);
+    }
+
+    /// @dev Applications linked to paused/archived risks may not be underwritten
+    function deactivate(RiskId riskId) external restricted() {
+        NftId productNftId = ObjectSetHelperLib.getProductNftId(_instanceAddress, riskId);
+        _deactivate(productNftId, riskId.toKey32());
+        emit LogRiskSetRiskPaused(productNftId, riskId);
+    }
+
+    function checkRisk(NftId productNftId, RiskId riskId)
+        public
+        view 
+        returns (bool exists, bool active)
+    {
+        Key32 riskKey32 = riskId.toKey32();
+        exists = _contains(productNftId, riskKey32);
+
+        if (exists) {
+            active = _isActive(productNftId, riskKey32);
+        }
+    }
+
+    function hasRisk(NftId productNftId, RiskId riskId)
+        public
+        view 
+        returns (bool)
+    {
+        Key32 riskKey32 = riskId.toKey32();
+        return _contains(productNftId, riskKey32);
+    }
+
+    function risks(NftId productNftId) external view returns(uint256) {
+        return _objects(productNftId);
+    }
+
+    function getRiskId(NftId productNftId, uint256 idx) external view returns(RiskId riskId) {
+        return RiskIdLib.toRiskId(_getObject(productNftId, idx).toKeyId());
+    }
+    
+    function activeRisks(NftId productNftId) external view returns(uint256) {
+        return _activeObjs(productNftId);
+    }
+
+    function getActiveRiskId(NftId productNftId, uint256 idx) external view returns(RiskId riskId) {
+        return RiskIdLib.toRiskId(_getActiveObject(productNftId, idx).toKeyId());
+    }
+
+    function linkedPolicies(RiskId riskId) external view returns(uint256) {
+        return LibNftIdSet.size(_activePolicies[riskId]);
+    }
+
+    function getLinkedPolicyNftId(RiskId riskId, uint256 idx) external view returns(NftId policyNftId) {
+        return LibNftIdSet.getElementAt(_activePolicies[riskId], idx);
+    }
+}

package/contracts/instance/TargetNames.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+string constant INSTANCE_TARGET_NAME = "Instance";
+string constant INSTANCE_ADMIN_TARGET_NAME = "InstanceAdmin";
+string constant INSTANCE_STORE_TARGET_NAME = "InstanceStore";
+string constant PRODUCT_STORE_TARGET_NAME = "ProductStore";
+string constant BUNDLE_SET_TARGET_NAME = "BundleSet";
+string constant RISK_SET_TARGET_NAME = "RiskSet";
+

package/contracts/instance/base/BalanceStore.sol

@@ -24,13 +24,12 @@ contract BalanceStore {
     mapping(NftId nftId => Amount balance) private _balanceAmount;
     mapping(NftId nftId => Amount locked) private _lockedAmount;
     mapping(NftId nftId => Amount fees) private _feeAmount;
-    mapping(NftId nftId => bool isRegistered) private _isRegistered;
 
-    // TODO check if this is made redundant by *Info struct updates
+    // used to indicate if the target has been registered as well as when it was last updated (not used externally atm)    
     mapping(NftId nftId => Blocknumber lastUpdatedIn) private _lastUpdatedIn;
 
     modifier onlyRegisteredTarget(NftId targetNftId) {
-        if (!_isRegistered[targetNftId]) {
+        if (!_lastUpdatedIn[targetNftId].gtz()) {
             revert ErrorBalanceStoreTargetNotRegistered(targetNftId);
         }
         _;
@@ -55,11 +54,10 @@ contract BalanceStore {
     }
 
     function _registerBalanceTarget(NftId targetNftId) internal {
-        if (_isRegistered[targetNftId]) {
+        if (_lastUpdatedIn[targetNftId].gtz()) {
             revert ErrorBalanceStoreTargetAlreadyRegistered(targetNftId);
         }
 
-        _isRegistered[targetNftId] = true;
         _setLastUpdatedIn(targetNftId);
 
         emit LogBalanceStoreTargetRegistered(targetNftId);
@@ -118,6 +116,6 @@ contract BalanceStore {
 
     //--- internal/private functions ----------------------------------------//
     function _setLastUpdatedIn(NftId targetNftId) internal {
-        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+        _lastUpdatedIn[targetNftId] = BlocknumberLib.current();
     }
 }

package/contracts/instance/base/ObjectCounter.sol

@@ -11,9 +11,8 @@ contract ObjectCounter {
     // TODO refactor risk id
     // mapping(NftId productNftId => uint64 risks) private _riskCounter;
 
-    uint256 private _requestCounter;
+    uint256 private _requestCounter = 0;
 
-    // TODO introduce RequestId (uint64)
     function _createNextRequestId() internal returns (RequestId requestId) {
         _requestCounter++;
         requestId = RequestIdLib.toRequestId(_requestCounter);

package/contracts/instance/base/ObjectLifecycle.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT, POOL, PREMIUM, PRODUCT, DISTRIBUTION, DISTRIBUTOR, DISTRIBUTOR_TYPE, REFERRAL, FEE} from "../../type/ObjectType.sol";
+import {ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../../type/StateId.sol";
+import {Lifecycle} from "../../shared/Lifecycle.sol";
+
+contract ObjectLifecycle is
+    Lifecycle,
+    Initializable
+{
+    function _initializeLifecycle() internal onlyInitializing
+    {
+        _setupLifecycle();
+    }
+
+    function _setupLifecycle()
+        internal
+        override
+    {
+        _setupBundleLifecycle();
+        _setupComponentLifecycle();
+        _setupPolicyLifecycle();
+        _setupPremiumLifecycle();
+        _setupClaimLifecycle();
+        _setupPayoutLifecycle();
+        _setupRiskLifecycle();
+        _setupRequestLifecycle();
+
+        // setup dummy lifecycles to manage with key value store 
+        _setUpPoolLifecycle();
+        _setUpProductLifecycle();
+        _setUpDistributionLifecycle();
+    }
+
+    function _setupComponentLifecycle() private {
+        setInitialState(COMPONENT(), ACTIVE());
+        setStateTransition(COMPONENT(), ACTIVE(), PAUSED());
+        setStateTransition(COMPONENT(), PAUSED(), ACTIVE());
+        setStateTransition(COMPONENT(), PAUSED(), ARCHIVED());
+    }
+
+    function _setupBundleLifecycle() private {
+        setInitialState(BUNDLE(), ACTIVE());
+        setStateTransition(BUNDLE(), ACTIVE(), CLOSED());
+    }
+
+    function _setupPolicyLifecycle() private {
+        setInitialState(POLICY(), APPLIED());
+        setStateTransition(POLICY(), APPLIED(), REVOKED());
+        setStateTransition(POLICY(), APPLIED(), DECLINED());
+        setStateTransition(POLICY(), APPLIED(), COLLATERALIZED());
+        setStateTransition(POLICY(), COLLATERALIZED(), CLOSED());
+    }
+
+    function _setupPremiumLifecycle() private {
+        setInitialState(PREMIUM(), EXPECTED());
+        setStateTransition(PREMIUM(), EXPECTED(), PAID());
+    }
+
+    function _setupClaimLifecycle() private {
+        setInitialState(CLAIM(), SUBMITTED());
+        setStateTransition(CLAIM(), SUBMITTED(), REVOKED());
+        setStateTransition(CLAIM(), SUBMITTED(), CONFIRMED());
+        setStateTransition(CLAIM(), SUBMITTED(), DECLINED());
+        setStateTransition(CLAIM(), CONFIRMED(), CLOSED());
+        setStateTransition(CLAIM(), CONFIRMED(), CANCELLED());
+    }
+
+    function _setupPayoutLifecycle() private {
+        setInitialState(PAYOUT(), EXPECTED());
+        setStateTransition(PAYOUT(), EXPECTED(), PAID());
+        setStateTransition(PAYOUT(), EXPECTED(), CANCELLED());
+    }
+
+    function _setupRiskLifecycle() private {
+        setInitialState(RISK(), ACTIVE());
+        setStateTransition(RISK(), ACTIVE(), CLOSED());
+    }
+
+    function _setupRequestLifecycle() private {
+        setInitialState(REQUEST(), ACTIVE());
+        setStateTransition(REQUEST(), ACTIVE(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), FAILED());
+        setStateTransition(REQUEST(), FAILED(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), CANCELLED());
+    }
+
+    // dummy lifecycle only
+    function _setUpPoolLifecycle() private {
+        setInitialState(POOL(), ACTIVE());
+    }
+
+    // dummy lifecycle only
+    function _setUpProductLifecycle() private {
+        setInitialState(PRODUCT(), ACTIVE());
+        setInitialState(FEE(), ACTIVE());
+    }
+
+    // dummy lifecycles only
+    function _setUpDistributionLifecycle() private {
+        setInitialState(DISTRIBUTION(), ACTIVE());
+        setInitialState(DISTRIBUTOR(), ACTIVE());
+        setInitialState(DISTRIBUTOR_TYPE(), ACTIVE());
+        setInitialState(REFERRAL(), ACTIVE());
+    }
+}

package/contracts/instance/base/ObjectSet.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Cloneable} from "./Cloneable.sol";
+
+import {LibKey32Set} from "../../type/Key32Set.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Key32} from "../../type/Key32.sol";
+
+contract ObjectSet is
+    Cloneable
+{
+    using LibKey32Set for LibKey32Set.Set;
+
+    event LogObjectSetInitialized(address instance);
+
+    error ErrorObjectSetNftIdInvalid(NftId instanceNftId);
+
+    mapping(NftId compnentNftId => LibKey32Set.Set objects) internal _activeObjects;
+    mapping(NftId compnentNftId => LibKey32Set.Set objects) internal _allObjects;
+    address internal _instanceAddress;
+
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize(address authority, address registry) 
+        external
+        initializer()
+    {
+        _instanceAddress = msg.sender;
+        __Cloneable_init(authority, registry);
+        
+        emit LogObjectSetInitialized(address(_instanceAddress));
+    }
+
+    function getInstanceAddress() external view returns (address) {
+        return _instanceAddress;
+    }
+
+    function _add(NftId componentNftId, Key32 key) internal {
+        LibKey32Set.Set storage allSet = _allObjects[componentNftId];
+        LibKey32Set.Set storage activeSet = _activeObjects[componentNftId];
+
+        allSet.add(key);
+        activeSet.add(key);
+    }
+
+    function _activate(NftId componentNftId, Key32 key) internal {
+        _activeObjects[componentNftId].add(key);
+    }
+
+    function _deactivate(NftId componentNftId, Key32 key) internal {
+        _activeObjects[componentNftId].remove(key);
+    }
+
+    function _objects(NftId componentNftId) internal view returns (uint256) {
+        return _allObjects[componentNftId].size();
+    }
+
+    function _contains(NftId componentNftId, Key32 key) internal view returns (bool) {
+        return _allObjects[componentNftId].contains(key);
+    }
+
+    function _getObject(NftId componentNftId, uint256 idx) internal view returns (Key32) {
+        return _allObjects[componentNftId].getElementAt(idx);
+    }
+
+    function _activeObjs(NftId componentNftId) internal view returns (uint256)  {
+        return _activeObjects[componentNftId].size();
+    }
+
+    function _isActive(NftId componentNftId, Key32 key) internal view returns (bool) {
+        return _activeObjects[componentNftId].contains(key);
+    }
+
+    function _getActiveObject(NftId componentNftId, uint256 idx) internal view returns (Key32) {
+        return _activeObjects[componentNftId].getElementAt(idx);
+    }
+}