@etherisc/gif-next 0.0.2-f398177-971 → 0.0.2-f3b4c66-505

package/contracts/instance/InstanceStore.sol

@@ -3,198 +3,284 @@ pragma solidity ^0.8.20;
 
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 
-import {Key32, KeyId, Key32Lib} from "../types/Key32.sol";
-import {NftId} from "../types/NftId.sol";
-import {ClaimId} from "../types/ClaimId.sol";
-import {NumberId} from "../types/NumberId.sol";
-import {ObjectType, BUNDLE, DISTRIBUTION, INSTANCE, POLICY, POOL, ROLE, PRODUCT, TARGET, COMPONENT, DISTRIBUTOR, DISTRIBUTOR_TYPE} from "../types/ObjectType.sol";
-import {RiskId, RiskIdLib} from "../types/RiskId.sol";
-import {RoleId, RoleIdLib, INSTANCE_ROLE, INSTANCE_OWNER_ROLE} from "../types/RoleId.sol";
-import {StateId, ACTIVE} from "../types/StateId.sol";
-import {TimestampLib} from "../types/Timestamp.sol";
-import {VersionPart, VersionPartLib} from "../types/Version.sol";
-import {ReferralId} from "../types/Referral.sol";
-import {DistributorType} from "../types/DistributorType.sol";
-import {PayoutId} from "../types/PayoutId.sol";
-
+import {Amount} from "../type/Amount.sol";
+import {Key32} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {ObjectType, BUNDLE, POLICY, POOL, PREMIUM, PRODUCT, COMPONENT, DISTRIBUTOR, FEE} from "../type/ObjectType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {StateId, KEEP_STATE} 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 {IInstance} from "./IInstance.sol";
-import {KeyValueStore} from "./base/KeyValueStore.sol";
-import {IKeyValueStore} from "./base/KeyValueStore.sol";
+import {KeyValueStore} from "../shared/KeyValueStore.sol";
+import {ObjectCounter} from "./base/ObjectCounter.sol";
 
 import {IBundle} from "./module/IBundle.sol";
 import {IComponents} from "./module/IComponents.sol";
 import {IDistribution} from "./module/IDistribution.sol";
 import {IPolicy} from "./module/IPolicy.sol";
+import {IOracle} from "../oracle/IOracle.sol";
 import {IRisk} from "./module/IRisk.sol";
-import {ISetup} from "./module/ISetup.sol";
+
+import {ObjectLifecycle} from "./base/ObjectLifecycle.sol";
 
 
-// TODO combine with instance reader?
-contract InstanceStore is AccessManagedUpgradeable, KeyValueStore
+contract InstanceStore is
+    AccessManagedUpgradeable, 
+    BalanceStore,
+    KeyValueStore,
+    ObjectCounter,
+    ObjectLifecycle
 {
-    function initialize(address instance)
+
+    /// @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);
-        initializeLifecycle();
+        // double initialization, safe
+        _initializeLifecycle();
     }
 
-    //--- ProductSetup ------------------------------------------------------//
-    function createProductSetup(NftId productNftId, ISetup.ProductSetupInfo memory setup) external restricted() {
-        create(_toNftKey32(productNftId, PRODUCT()), abi.encode(setup));
-    }
+    //--- Component ---------------------------------------------------------//
 
-    function updateProductSetup(NftId productNftId, ISetup.ProductSetupInfo memory setup, StateId newState) external restricted() {
-        update(_toNftKey32(productNftId, PRODUCT()), abi.encode(setup), newState);
+    function createComponent(
+        NftId componentNftId, 
+        IComponents.ComponentInfo memory componentInfo
+    )
+        external 
+        restricted()
+    {
+        _registerBalanceTarget(componentNftId);
+        _create(_toNftKey32(componentNftId, COMPONENT()), abi.encode(componentInfo));
     }
 
-    function updateProductSetupState(NftId productNftId, StateId newState) external restricted() {
-        updateState(_toNftKey32(productNftId, PRODUCT()), newState);
+    function updateComponent(
+        NftId componentNftId, 
+        IComponents.ComponentInfo memory componentInfo,
+        StateId newState
+    )
+        external 
+        restricted()
+    {
+        _update(_toNftKey32(componentNftId, COMPONENT()), abi.encode(componentInfo), newState);
     }
 
-    //--- DistributionSetup ------------------------------------------------------//
-    function createDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup) external restricted() {
-        create(_toNftKey32(distributionNftId, DISTRIBUTION()), abi.encode(setup));
+    //--- Product -----------------------------------------------------------//
+
+    function createProduct(NftId productNftId, IComponents.ProductInfo memory info) external restricted() {
+        _create(_toNftKey32(productNftId, PRODUCT()), abi.encode(info));
     }
 
-    function updateDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup, StateId newState) external restricted() {
-        update(_toNftKey32(distributionNftId, DISTRIBUTION()), abi.encode(setup), newState);
+    function updateProduct(NftId productNftId, IComponents.ProductInfo memory info, StateId newState) external restricted() {
+        _update(_toNftKey32(productNftId, PRODUCT()), abi.encode(info), newState);
     }
 
-    function updateDistributionSetupState(NftId distributionNftId, StateId newState) external restricted() {
-        updateState(_toNftKey32(distributionNftId, DISTRIBUTION()), newState);
+
+    //--- Fee -----------------------------------------------------------//
+    function createFee(NftId productNftId, IComponents.FeeInfo memory info) external restricted() {
+        _create(_toNftKey32(productNftId, FEE()), abi.encode(info));
     }
 
-    //--- PoolSetup ------------------------------------------------------//
-    function createPoolSetup(NftId poolNftId, IComponents.ComponentInfo memory info) external restricted() {
-        create(_toNftKey32(poolNftId, POOL()), abi.encode(info));
+    // Fee only has one state, so no change change possible
+    function updateFee(NftId productNftId, IComponents.FeeInfo memory info) external restricted() {
+        _update(_toNftKey32(productNftId, FEE()), abi.encode(info), KEEP_STATE());
     }
 
-    function updatePoolSetup(NftId poolNftId, IComponents.ComponentInfo memory info, StateId newState) external restricted() {
-        update(_toNftKey32(poolNftId, POOL()), abi.encode(info), newState);
+    //--- Pool --------------------------------------------------------------//
+
+    function createPool(
+        NftId poolNftId, 
+        IComponents.PoolInfo memory info
+    )
+        external 
+        restricted()
+    {
+        _create(_toNftKey32(poolNftId, POOL()), abi.encode(info));
     }
 
-    function updatePoolSetupState(NftId poolNftId, StateId newState) external restricted() {
-        updateState(_toNftKey32(poolNftId, POOL()), newState);
+    function updatePool(NftId poolNftId, IComponents.PoolInfo memory info, StateId newState) external restricted() {
+        _update(_toNftKey32(poolNftId, POOL()), abi.encode(info), newState);
     }
 
-    //--- DistributorType -------------------------------------------------------//
+    //--- DistributorType ---------------------------------------------------//
     function createDistributorType(DistributorType distributorType, IDistribution.DistributorTypeInfo memory info) external restricted() {
-        create(distributorType.toKey32(), abi.encode(info));
+        _create(distributorType.toKey32(), abi.encode(info));
     }
 
     function updateDistributorType(DistributorType distributorType, IDistribution.DistributorTypeInfo memory info, StateId newState) external restricted() {
-        update(distributorType.toKey32(), abi.encode(info), newState);
+        _update(distributorType.toKey32(), abi.encode(info), newState);
     }
 
     function updateDistributorTypeState(DistributorType distributorType, StateId newState) external restricted() {
-        updateState(distributorType.toKey32(), newState);
+        _updateState(distributorType.toKey32(), newState);
     }
 
     //--- Distributor -------------------------------------------------------//
     function createDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info) external restricted() {
-        create(_toNftKey32(distributorNftId, DISTRIBUTOR()), abi.encode(info));
+        _registerBalanceTarget(distributorNftId);
+        _create(_toNftKey32(distributorNftId, DISTRIBUTOR()), abi.encode(info));
     }
 
     function updateDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info, StateId newState) external restricted() {
-        update(_toNftKey32(distributorNftId, DISTRIBUTOR()), abi.encode(info), newState);
+        _update(_toNftKey32(distributorNftId, DISTRIBUTOR()), abi.encode(info), newState);
     }
 
     function updateDistributorState(NftId distributorNftId, StateId newState) external restricted() {
-        updateState(_toNftKey32(distributorNftId, DISTRIBUTOR()), newState);
+        _updateState(_toNftKey32(distributorNftId, DISTRIBUTOR()), newState);
     }
 
     //--- Referral ----------------------------------------------------------//
     function createReferral(ReferralId referralId, IDistribution.ReferralInfo memory referralInfo) external restricted() {
-        create(referralId.toKey32(), abi.encode(referralInfo));
+        _create(referralId.toKey32(), abi.encode(referralInfo));
     }
 
     function updateReferral(ReferralId referralId, IDistribution.ReferralInfo memory referralInfo, StateId newState) external restricted() {
-        update(referralId.toKey32(), abi.encode(referralInfo), newState);
+        _update(referralId.toKey32(), abi.encode(referralInfo), newState);
     }
 
     function updateReferralState(ReferralId referralId, StateId newState) external restricted() {
-        updateState(referralId.toKey32(), newState);
+        _updateState(referralId.toKey32(), newState);
     }
 
     //--- Bundle ------------------------------------------------------------//
     function createBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle) external restricted() {
-        create(_toNftKey32(bundleNftId, BUNDLE()), abi.encode(bundle));
+        _registerBalanceTarget(bundleNftId);
+        _create(_toNftKey32(bundleNftId, BUNDLE()), abi.encode(bundle));
     }
 
     function updateBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle, StateId newState) external restricted() {
-        update(_toNftKey32(bundleNftId, BUNDLE()), abi.encode(bundle), newState);
+        _update(_toNftKey32(bundleNftId, BUNDLE()), abi.encode(bundle), newState);
     }
 
     function updateBundleState(NftId bundleNftId, StateId newState) external restricted() {
-        updateState(_toNftKey32(bundleNftId, BUNDLE()), newState);
+        _updateState(_toNftKey32(bundleNftId, BUNDLE()), newState);
     }
 
     //--- Risk --------------------------------------------------------------//
     function createRisk(RiskId riskId, IRisk.RiskInfo memory risk) external restricted() {
-        create(riskId.toKey32(), abi.encode(risk));
+        _create(riskId.toKey32(), abi.encode(risk));
     }
 
     function updateRisk(RiskId riskId, IRisk.RiskInfo memory risk, StateId newState) external restricted() {
-        update(riskId.toKey32(), abi.encode(risk), newState);
+        _update(riskId.toKey32(), abi.encode(risk), newState);
     }
 
     function updateRiskState(RiskId riskId, StateId newState) external restricted() {
-        updateState(riskId.toKey32(), newState);
+        _updateState(riskId.toKey32(), newState);
     }
 
     //--- Application (Policy) ----------------------------------------------//
     function createApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy) external restricted() {
-        create(_toNftKey32(applicationNftId, POLICY()), abi.encode(policy));
+        _registerBalanceTarget(applicationNftId);
+        _create(_toNftKey32(applicationNftId, POLICY()), abi.encode(policy));
     }
 
     function updateApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
-        update(_toNftKey32(applicationNftId, POLICY()), abi.encode(policy), newState);
+        _update(_toNftKey32(applicationNftId, POLICY()), abi.encode(policy), newState);
     }
 
     function updateApplicationState(NftId applicationNftId, StateId newState) external restricted() {
-        updateState(_toNftKey32(applicationNftId, POLICY()), newState);
+        _updateState(_toNftKey32(applicationNftId, POLICY()), newState);
     }
 
     //--- Policy ------------------------------------------------------------//
     function updatePolicy(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
-        update(_toNftKey32(policyNftId, POLICY()), abi.encode(policy), newState);
+        _update(_toNftKey32(policyNftId, POLICY()), abi.encode(policy), newState);
     }
 
     function updatePolicyClaims(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
-        update(_toNftKey32(policyNftId, POLICY()), abi.encode(policy), newState);
+        _update(_toNftKey32(policyNftId, POLICY()), abi.encode(policy), newState);
     }
 
     function updatePolicyState(NftId policyNftId, StateId newState) external restricted() {
-        updateState(_toNftKey32(policyNftId, POLICY()), newState);
+        _updateState(_toNftKey32(policyNftId, POLICY()), newState);
+    }
+
+    
+    //--- Premium (Policy) ----------------------------------------------//
+    function createPremium(NftId policyNftId, IPolicy.PremiumInfo memory premium) external restricted() {
+        _create(_toNftKey32(policyNftId, PREMIUM()), abi.encode(premium));
+    }
+
+    function updatePremiumState(NftId policyNftId, StateId newState) external restricted() {
+        _updateState(_toNftKey32(policyNftId, PREMIUM()), newState);
     }
 
     //--- Claim -------------------------------------------------------------//
     function createClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim) external restricted() {
-        create(_toClaimKey32(policyNftId, claimId), abi.encode(claim));
+        _create(_toClaimKey32(policyNftId, claimId), abi.encode(claim));
     }
 
     function updateClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim, StateId newState) external restricted() {
-        update(_toClaimKey32(policyNftId, claimId), abi.encode(claim), newState);
+        _update(_toClaimKey32(policyNftId, claimId), abi.encode(claim), newState);
     }
 
     function updateClaimState(NftId policyNftId, ClaimId claimId, StateId newState) external restricted() {
-        updateState(_toClaimKey32(policyNftId, claimId), newState);
+        _updateState(_toClaimKey32(policyNftId, claimId), newState);
     }
 
     //--- Payout ------------------------------------------------------------//
     function createPayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout) external restricted() {
-        create(_toPayoutKey32(policyNftId, payoutId), abi.encode(payout));
+        _create(_toPayoutKey32(policyNftId, payoutId), abi.encode(payout));
     }
 
     function updatePayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout, StateId newState) external restricted() {
-        update(_toPayoutKey32(policyNftId, payoutId), abi.encode(payout), newState);
+        _update(_toPayoutKey32(policyNftId, payoutId), abi.encode(payout), newState);
     }
 
     function updatePayoutState(NftId policyNftId, PayoutId payoutId, StateId newState) external restricted() {
-        updateState(_toPayoutKey32(policyNftId, payoutId), newState);
+        _updateState(_toPayoutKey32(policyNftId, payoutId), newState);
+    }
+
+    //--- Request -----------------------------------------------------------//
+
+    function createRequest(IOracle.RequestInfo memory request) external restricted() returns (RequestId requestId) {
+        requestId = _createNextRequestId();
+        _create(requestId.toKey32(), abi.encode(request));
+    }
+
+    function updateRequest(RequestId requestId, IOracle.RequestInfo memory request, StateId newState) external restricted() {
+        _update(requestId.toKey32(), abi.encode(request), newState);
+    }
+
+    function updateRequestState(RequestId requestId, StateId newState) external restricted() {
+        _updateState(requestId.toKey32(), newState);
+    }
+
+    //--- 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 --------------------------------------//

package/contracts/instance/RiskSet.sol

@@ -0,0 +1,118 @@
+// 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);
+    event LogRiskSetRiskArchived(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 pause(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 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/base/BalanceStore.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, BlocknumberLib} from "../../type/Blocknumber.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Amount} from "../../type/Amount.sol";
+
+contract BalanceStore {
+
+    error ErrorBalanceStoreTargetAlreadyRegistered(NftId targetNftId);
+    error ErrorBalanceStoreTargetNotRegistered(NftId targetNftId);
+
+    event LogBalanceStoreTargetRegistered(NftId targetNftId);
+
+    event LogBalanceStoreFeesIncreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    event LogBalanceStoreFeesDecreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    event LogBalanceStoreLockedIncreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    event LogBalanceStoreLockedDecreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    event LogBalanceStoreBalanceIncreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+    event LogBalanceStoreBalanceDecreased(NftId targetNftId, Amount addedAmount, Amount newBalance, Blocknumber lastUpdatedIn);
+
+    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
+    mapping(NftId nftId => Blocknumber lastUpdatedIn) private _lastUpdatedIn;
+
+    modifier onlyRegisteredTarget(NftId targetNftId) {
+        if (!_isRegistered[targetNftId]) {
+            revert ErrorBalanceStoreTargetNotRegistered(targetNftId);
+        }
+        _;
+    }
+
+    function getBalanceAmount(NftId targetNftId) external view returns (Amount balanceAmount) { return _balanceAmount[targetNftId]; }
+    function getLockedAmount(NftId targetNftId) external view returns (Amount lockedAmount) { return _lockedAmount[targetNftId]; }
+    function getFeeAmount(NftId targetNftId) external view returns (Amount feeAmount) { return _feeAmount[targetNftId]; }
+
+    function getAmounts(NftId targetNftId)
+        external
+        view
+        returns (
+            Amount balanceAmount,
+            Amount lockedAmount,
+            Amount feeAmount
+        )
+    {
+        balanceAmount = _balanceAmount[targetNftId];
+        lockedAmount = _lockedAmount[targetNftId];
+        feeAmount = _feeAmount[targetNftId];
+    }
+
+    function _registerBalanceTarget(NftId targetNftId) internal {
+        if (_isRegistered[targetNftId]) {
+            revert ErrorBalanceStoreTargetAlreadyRegistered(targetNftId);
+        }
+
+        _isRegistered[targetNftId] = true;
+        _setLastUpdatedIn(targetNftId);
+
+        emit LogBalanceStoreTargetRegistered(targetNftId);
+    }
+
+    //--- fee management ----------------------------------------------------//
+    function _increaseFees(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _feeAmount[targetNftId] + amount;
+        _feeAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreFeesIncreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    function _decreaseFees(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _feeAmount[targetNftId] - amount;
+        _feeAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreFeesDecreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    //--- locked management -------------------------------------------------//
+    function _increaseLocked(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _lockedAmount[targetNftId] + amount;
+        _lockedAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreLockedIncreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    function _decreaseLocked(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _lockedAmount[targetNftId] - amount;
+        _lockedAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreLockedDecreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    //--- balance management ------------------------------------------------//
+    function _increaseBalance(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _balanceAmount[targetNftId] + amount;
+        _balanceAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreBalanceIncreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    function _decreaseBalance(NftId targetNftId, Amount amount) internal onlyRegisteredTarget(targetNftId) returns (Amount newBalance) {
+        newBalance = _balanceAmount[targetNftId] - amount;
+        _balanceAmount[targetNftId] = newBalance;
+
+        emit LogBalanceStoreBalanceDecreased(targetNftId, amount, newBalance, _lastUpdatedIn[targetNftId]);
+        _setLastUpdatedIn(targetNftId);
+    }
+
+    //--- internal/private functions ----------------------------------------//
+    function _setLastUpdatedIn(NftId targetNftId) internal {
+        _lastUpdatedIn[targetNftId] = BlocknumberLib.currentBlocknumber();
+    }
+}

package/contracts/instance/base/Cloneable.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+
+import {IRegistry} from "../../registry/IRegistry.sol";
+
+abstract contract Cloneable is 
+    AccessManagedUpgradeable
+{
+    IRegistry internal _registry;
+
+    /// @dev call to initialize MUST be made in the same transaction as cloning of the contract
+    function __Cloneable_init(
+        address authority,
+        address registry
+    )
+        internal 
+        onlyInitializing
+    {
+        __AccessManaged_init(authority);
+        _registry = IRegistry(registry);
+    }
+
+    function getRegistry() external view returns (IRegistry) {
+        return _registry;
+    }
+}

package/contracts/instance/base/ObjectCounter.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, BlocknumberLib} from "../../type/Blocknumber.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Amount} from "../../type/Amount.sol";
+import {RequestId, RequestIdLib} from "../../type/RequestId.sol";
+
+contract ObjectCounter {
+
+    // TODO refactor risk id
+    // mapping(NftId productNftId => uint64 risks) private _riskCounter;
+
+    uint256 private _requestCounter = 0;
+
+    function _createNextRequestId() internal returns (RequestId requestId) {
+        _requestCounter++;
+        requestId = RequestIdLib.toRequestId(_requestCounter);
+    }
+}