@etherisc/gif-next 0.0.2-d5b7b78-706 → 0.0.2-d5fac82-078

package/contracts/instance/InstanceStore.sol

@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+
+import {Key32, KeyId, Key32Lib} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {ObjectType, BUNDLE, DISTRIBUTION, INSTANCE, POLICY, POOL, ROLE, PRODUCT, TARGET, COMPONENT, DISTRIBUTOR, DISTRIBUTOR_TYPE} from "../type/ObjectType.sol";
+import {RiskId, RiskIdLib} from "../type/RiskId.sol";
+import {RoleId, RoleIdLib, INSTANCE_ROLE, INSTANCE_OWNER_ROLE} from "../type/RoleId.sol";
+import {StateId, ACTIVE} from "../type/StateId.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+
+import {IInstance} from "./IInstance.sol";
+import {KeyValueStore} from "./base/KeyValueStore.sol";
+import {IKeyValueStore} from "./base/KeyValueStore.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 {IRisk} from "./module/IRisk.sol";
+import {ISetup} from "./module/ISetup.sol";
+
+
+// TODO combine with instance reader?
+contract InstanceStore is AccessManagedUpgradeable, KeyValueStore
+{
+    function initialize(address instance)
+        public 
+        initializer()
+    {
+        address authority = IInstance(instance).authority();
+        __AccessManaged_init(authority);
+        initializeLifecycle();
+    }
+
+    //--- ProductSetup ------------------------------------------------------//
+    function createProductSetup(NftId productNftId, ISetup.ProductSetupInfo memory setup) external restricted() {
+        create(_toNftKey32(productNftId, PRODUCT()), abi.encode(setup));
+    }
+
+    function updateProductSetup(NftId productNftId, ISetup.ProductSetupInfo memory setup, StateId newState) external restricted() {
+        update(_toNftKey32(productNftId, PRODUCT()), abi.encode(setup), newState);
+    }
+
+    function updateProductSetupState(NftId productNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(productNftId, PRODUCT()), newState);
+    }
+
+    //--- DistributionSetup ------------------------------------------------------//
+    function createDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup) external restricted() {
+        create(_toNftKey32(distributionNftId, DISTRIBUTION()), abi.encode(setup));
+    }
+
+    function updateDistributionSetup(NftId distributionNftId, ISetup.DistributionSetupInfo memory setup, StateId newState) external restricted() {
+        update(_toNftKey32(distributionNftId, DISTRIBUTION()), abi.encode(setup), newState);
+    }
+
+    function updateDistributionSetupState(NftId distributionNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(distributionNftId, DISTRIBUTION()), newState);
+    }
+
+    //--- PoolSetup ------------------------------------------------------//
+    function createPoolSetup(NftId poolNftId, IComponents.ComponentInfo memory info) external restricted() {
+        create(_toNftKey32(poolNftId, POOL()), abi.encode(info));
+    }
+
+    function updatePoolSetup(NftId poolNftId, IComponents.ComponentInfo memory info, StateId newState) external restricted() {
+        update(_toNftKey32(poolNftId, POOL()), abi.encode(info), newState);
+    }
+
+    function updatePoolSetupState(NftId poolNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(poolNftId, POOL()), newState);
+    }
+
+    //--- DistributorType -------------------------------------------------------//
+    function createDistributorType(DistributorType distributorType, IDistribution.DistributorTypeInfo memory info) external restricted() {
+        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);
+    }
+
+    function updateDistributorTypeState(DistributorType distributorType, StateId newState) external restricted() {
+        updateState(distributorType.toKey32(), newState);
+    }
+
+    //--- Distributor -------------------------------------------------------//
+    function createDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info) external restricted() {
+        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);
+    }
+
+    function updateDistributorState(NftId distributorNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(distributorNftId, DISTRIBUTOR()), newState);
+    }
+
+    //--- Referral ----------------------------------------------------------//
+    function createReferral(ReferralId referralId, IDistribution.ReferralInfo memory referralInfo) external restricted() {
+        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);
+    }
+
+    function updateReferralState(ReferralId referralId, StateId newState) external restricted() {
+        updateState(referralId.toKey32(), newState);
+    }
+
+    //--- Bundle ------------------------------------------------------------//
+    function createBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle) external restricted() {
+        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);
+    }
+
+    function updateBundleState(NftId bundleNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(bundleNftId, BUNDLE()), newState);
+    }
+
+    //--- Risk --------------------------------------------------------------//
+    function createRisk(RiskId riskId, IRisk.RiskInfo memory risk) external restricted() {
+        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);
+    }
+
+    function updateRiskState(RiskId riskId, StateId newState) external restricted() {
+        updateState(riskId.toKey32(), newState);
+    }
+
+    //--- Application (Policy) ----------------------------------------------//
+    function createApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy) external restricted() {
+        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);
+    }
+
+    function updateApplicationState(NftId applicationNftId, StateId newState) external restricted() {
+        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);
+    }
+
+    function updatePolicyClaims(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        update(_toNftKey32(policyNftId, POLICY()), abi.encode(policy), newState);
+    }
+
+    function updatePolicyState(NftId policyNftId, StateId newState) external restricted() {
+        updateState(_toNftKey32(policyNftId, POLICY()), newState);
+    }
+
+    //--- Claim -------------------------------------------------------------//
+    function createClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim) external restricted() {
+        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);
+    }
+
+    function updateClaimState(NftId policyNftId, ClaimId claimId, StateId newState) external restricted() {
+        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));
+    }
+
+    function updatePayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout, StateId newState) external restricted() {
+        update(_toPayoutKey32(policyNftId, payoutId), abi.encode(payout), newState);
+    }
+
+    function updatePayoutState(NftId policyNftId, PayoutId payoutId, StateId newState) external restricted() {
+        updateState(_toPayoutKey32(policyNftId, payoutId), newState);
+    }
+
+    //--- 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/{Cloneable.sol → base/Cloneable.sol}

@@ -4,7 +4,7 @@ pragma solidity ^0.8.20;
 import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
-import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
 
 abstract contract Cloneable is 
     AccessManagedUpgradeable

package/contracts/instance/base/IKeyValueStore.sol

@@ -1,17 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
-import {Key32, KeyId} from "../../types/Key32.sol";
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId} from "../../types/StateId.sol";
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../type/Blocknumber.sol";
+import {Key32, KeyId} from "../../type/Key32.sol";
+import {NftId} from "../../type/NftId.sol";
+import {ObjectType} from "../../type/ObjectType.sol";
+import {StateId} from "../../type/StateId.sol";
 
 import {ILifecycle} from "./ILifecycle.sol";
 
-// TODO remove - internal only?
 interface IKeyValueStore is ILifecycle {
 
+    error ErrorKeyValueStoreTypeUndefined(ObjectType objectType);
+    error ErrorKeyValueStoreAlreadyCreated(Key32 key, ObjectType objectType);
+    error ErrorKeyValueStoreStateZero(Key32 key);
+    error ErrorKeyValueStoreNotExisting(Key32 key);
+
+    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
+    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+
     struct Value {
         Metadata metadata;
         bytes data;
@@ -29,10 +37,6 @@ interface IKeyValueStore is ILifecycle {
         Blocknumber createdIn;
     }
 
-    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
-    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
-    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
-
     // generic state changing functions
     // function create(Key32 key, bytes memory data) external;
     // function update(Key32 key, bytes memory data, StateId state) external;

package/contracts/instance/base/ILifecycle.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId} from "../../types/StateId.sol";
+import {NftId} from "../../type/NftId.sol";
+import {ObjectType} from "../../type/ObjectType.sol";
+import {StateId} from "../../type/StateId.sol";
 
 interface ILifecycle {
 

package/contracts/instance/base/KeyValueStore.sol

@@ -1,17 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
-import {Key32, KeyId, Key32Lib} from "../../types/Key32.sol";
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId, ACTIVE} from "../../types/StateId.sol";
-import {Timestamp, TimestampLib} from "../../types/Timestamp.sol";
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../type/Blocknumber.sol";
+import {Key32, KeyId, Key32Lib} from "../../type/Key32.sol";
+import {NftId} from "../../type/NftId.sol";
+import {ObjectType} from "../../type/ObjectType.sol";
+import {StateId, ACTIVE, KEEP_STATE} from "../../type/StateId.sol";
+import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
 
 import {Lifecycle} from "./Lifecycle.sol";
 import {IKeyValueStore} from "./IKeyValueStore.sol";
 
-contract KeyValueStore is Lifecycle, IKeyValueStore {
+contract KeyValueStore is
+    Lifecycle, 
+    IKeyValueStore
+{
 
     mapping(Key32 key32 => Value value) private _value;
 
@@ -20,21 +23,16 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         bytes memory data
     )
         internal
-    {
-        _create(key32, data);
-    }
-
-    function _create(
-        Key32 key32, 
-        bytes memory data
-    )
-        internal
     {
         ObjectType objectType = key32.toObjectType();
-        require(objectType.gtz(), "ERROR:KVS-010:TYPE_UNDEFINED");
+        if (objectType.eqz()) {
+            revert ErrorKeyValueStoreTypeUndefined(objectType);
+        }
 
         Metadata storage metadata = _value[key32].metadata;
-        require(metadata.state.eqz(), "ERROR:KVS-012:ALREADY_CREATED");
+        if (metadata.state.gtz()) {
+            revert ErrorKeyValueStoreAlreadyCreated(key32, objectType);
+        }
 
         address createdBy = msg.sender;
         Blocknumber blocknumber = blockBlocknumber();
@@ -61,28 +59,29 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
     ) 
         internal
     {
-        _update(key32, data, state);
-    }
+        if (state.eqz()) {
+            revert ErrorKeyValueStoreStateZero(key32);
+        }
 
-    function _update(
-        Key32 key32, 
-        bytes memory data,
-        StateId state
-    ) 
-        internal
-    {
-        require(state.gtz(), "ERROR:KVS-020:STATE_UNDEFINED");
         Metadata storage metadata = _value[key32].metadata;
         StateId stateOld = metadata.state;
-        require(stateOld.gtz(), "ERROR:KVS-021:NOT_EXISTING");
+        if (stateOld.eqz()) {
+            revert ErrorKeyValueStoreNotExisting(key32);
+        }
 
         // update data
         _value[key32].data = data;
 
-        // update metadata (and state)
+        // update state 
+        if(state != KEEP_STATE()) {
+            checkTransition(metadata.objectType, stateOld, state);
+            metadata.state = state;
+        }
+
+        // update reest of metadata
         address updatedBy = msg.sender;
         Blocknumber lastUpdatedIn = metadata.updatedIn;
-        metadata.state = state;
+
         metadata.updatedBy = updatedBy;
         metadata.updatedIn = blockBlocknumber();
 
@@ -95,16 +94,12 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
 
     function updateData(Key32 key32, bytes memory data) 
         internal
-    {
-        _updateData(key32, data);
-    }
-
-    function _updateData(Key32 key32, bytes memory data) 
-        internal
     {
         Metadata storage metadata = _value[key32].metadata;
         StateId state = metadata.state;
-        require(state.gtz(), "ERROR:KVS-030:NOT_EXISTING");
+        if (state.eqz()) {
+            revert ErrorKeyValueStoreNotExisting(key32);
+        }
 
         // update data
         _value[key32].data = data;
@@ -123,16 +118,15 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
     function updateState(Key32 key32, StateId state)
         internal
     {
-        _updateState(key32, state);
-    }
+        if (state.eqz()) {
+            revert ErrorKeyValueStoreStateZero(key32);
+        }
 
-    function _updateState(Key32 key32, StateId state)
-        internal
-    {
-        require(state.gtz(), "ERROR:KVS-040:STATE_UNDEFINED");
         Metadata storage metadata = _value[key32].metadata;
         StateId stateOld = metadata.state;
-        require(stateOld.gtz(), "ERROR:KVS-041:NOT_EXISTING");
+        if (stateOld.eqz()) {
+            revert ErrorKeyValueStoreNotExisting(key32);
+        }
 
         // ensure state transistion is valid
         checkTransition(metadata.objectType, stateOld, state);

package/contracts/instance/base/Lifecycle.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK} from "../../types/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, UNDERWRITTEN, REVOKED, DECLINED} from "../../types/StateId.sol";
+import {NftId} from "../../type/NftId.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK, CLAIM, PAYOUT} from "../../type/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID} from "../../type/StateId.sol";
 import {ILifecycle} from "./ILifecycle.sol";
 
 contract Lifecycle is
@@ -25,6 +25,7 @@ contract Lifecycle is
         _setupBundleLifecycle();
         _setupComponentLifecycle();
         _setupPolicyLifecycle();
+        _setupClaimAndPayoutLifecycle();
         _setupRiskLifecycle();
     }
 
@@ -95,11 +96,22 @@ contract Lifecycle is
         _initialState[POLICY()] = APPLIED();
         _isValidTransition[POLICY()][APPLIED()][REVOKED()] = true;
         _isValidTransition[POLICY()][APPLIED()][DECLINED()] = true;
-        _isValidTransition[POLICY()][APPLIED()][UNDERWRITTEN()] = true;
-        _isValidTransition[POLICY()][UNDERWRITTEN()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][APPLIED()][COLLATERALIZED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][COLLATERALIZED()][ACTIVE()] = true;
         _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
     }
 
+    function _setupClaimAndPayoutLifecycle() internal {
+        _initialState[CLAIM()] = SUBMITTED();
+        _isValidTransition[CLAIM()][SUBMITTED()][CONFIRMED()] = true;
+        _isValidTransition[CLAIM()][SUBMITTED()][DECLINED()] = true;
+        _isValidTransition[CLAIM()][CONFIRMED()][CLOSED()] = true;
+
+        _initialState[PAYOUT()] = EXPECTED();
+        _isValidTransition[PAYOUT()][EXPECTED()][PAID()] = true;
+    }
+
     function _setupRiskLifecycle() internal {
         _initialState[RISK()] = ACTIVE();
         _isValidTransition[RISK()][ACTIVE()][PAUSED()] = true;

package/contracts/instance/{ObjectManager.sol → base/ObjectManager.sol}

@@ -3,12 +3,12 @@ pragma solidity ^0.8.20;
 
 import {Cloneable} from "./Cloneable.sol";
 
-import {IInstance} from "./IInstance.sol";
-import {INSTANCE} from "../types/ObjectType.sol";
-import {InstanceReader} from "./InstanceReader.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {LibNftIdSet} from "../types/NftIdSet.sol";
-import {NftId} from "../types/NftId.sol";
+import {IInstance} from "../IInstance.sol";
+import {INSTANCE} from "../../type/ObjectType.sol";
+import {InstanceReader} from "../InstanceReader.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {LibNftIdSet} from "../../type/NftIdSet.sol";
+import {NftId} from "../../type/NftId.sol";
 
 contract ObjectManager is
     Cloneable
@@ -29,7 +29,7 @@ contract ObjectManager is
         external 
     {
         IInstance instance = IInstance(instanceAddress);
-        initialize(instance.authority(), instance.getRegistryAddress());
+        initialize(instance.authority(), address(instance.getRegistry()));
 
         _instance = instance;
         

package/contracts/instance/module/IAccess.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8.20;
 
 import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
 
-import {RoleId} from "../../types/RoleId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+import {RoleId} from "../../type/RoleId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IAccess {
 
@@ -32,22 +32,12 @@ interface IAccess {
         Timestamp updatedAt;
     }
 
-    error ErrorIAccessCallerIsNotRoleAdmin(address caller, RoleId roleId);
-
-    error ErrorIAccessRoleIdDoesNotExist(RoleId roleId);
     error ErrorIAccessRoleIdTooBig(RoleId roleId);
     error ErrorIAccessRoleIdTooSmall(RoleId roleId);
-    error ErrorIAccessRoleIdExists(RoleId roleId);
-    error ErrorIAccessRoleNameEmpty(RoleId roleId);
-    error ErrorIAccessRoleNameExists(RoleId roleId, RoleId existingRoleId, ShortString name);
     error ErrorIAccessRoleTypeInvalid(RoleId roleId, Type rtype);
 
     error ErrorIAccessTargetAddressZero();
-    error ErrorIAccessTargetDoesNotExist(ShortString name);
-    error ErrorIAccessTargetExists(address target, ShortString name);
-    error ErrorIAccessTargetTypeInvalid(ShortString name, Type ttype);
-    error ErrorIAccessTargetNameEmpty(address target);
-    error ErrorIAccessTargetNameExists(address target, address existingTarget, ShortString name);
+    error ErrorIAccessTargetTypeInvalid(address target, Type ttype);
     error ErrorIAccessTargetLocked(address target);
     error ErrorIAccessTargetNotRegistered(address target);
     error ErrorIAccessTargetAuthorityInvalid(address target, address targetAuthority);

package/contracts/instance/module/IBundle.sol

@@ -1,21 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {Fee} from "../../types/Fee.sol";
-import {Seconds} from "../../types/Seconds.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+import {Amount} from "../../type/Amount.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Fee} from "../../type/Fee.sol";
+import {Seconds} from "../../type/Seconds.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IBundle {
+
     struct BundleInfo {
         NftId poolNftId;
         Fee fee; // bundle fee on net premium amounts
         bytes filter; // required conditions for applications to be considered for collateralization by this bundle
-        uint256 capitalAmount; // net investment capital + net premiums - payouts
-        uint256 lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= balance)
-        uint256 balanceAmount; // total amount of funds: capitalAmount + fees (balance >= captial)
+        Amount capitalAmount; // net stakings + net premiums - payouts
+        Amount lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= capital amount)
+        Amount feeAmount; // accumulated fee amount
         Seconds lifetime;
-        Timestamp expiredAt; // no new policies
+        Timestamp expiredAt; // no new policies starting with this timestamp
         Timestamp closedAt; // no open policies, locked amount = 0
     }
 }

package/contracts/instance/module/IComponents.sol

@@ -3,11 +3,12 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-import {Fee} from "../../types/Fee.sol";
-import {NftId} from "../../types/NftId.sol";
-import {RoleId} from "../../types/RoleId.sol";
+import {Amount} from "../../type/Amount.sol";
+import {Fee} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
+import {RoleId} from "../../type/RoleId.sol";
 import {TokenHandler} from "../../shared/TokenHandler.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
 interface IComponents {
 
@@ -16,13 +17,18 @@ interface IComponents {
         IERC20Metadata token;
         TokenHandler tokenHandler;
         address wallet;
+        Amount balanceAmount; // calculated balance (may not necessarily match withg wallet balance)
+        Amount feeAmount; // accumulated fees belonging to component owner
         bytes data; // will hold component type specific additional info (eg encoded pool info)
     }
 
     struct PoolInfo {
         NftId productNftId; // the nft of the product this pool is linked to
         RoleId bundleOwnerRole; // the required role for bundle owners
-        uint256 maxCapitalAmount; // max capital amount allowed for pool
+        // TODO maxCapitalAmount -> maxBalanceAmount
+        Amount maxCapitalAmount; // max capital amount allowed for pool
+        Amount balanceAmount; // current pool balance (accounting view)
+        Amount feeAmount; // accumulated fee amount
         bool isInterceptingBundleTransfers; // intercepts nft transfers for bundles
         bool isExternallyManaged; // funding bundles is restricted to book keeping, actual funds may be provided as needed to support payouts
         bool isVerifyingApplications; // underwriting requires the pool component checks/confirms the applications 

package/contracts/instance/module/IDistribution.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {DistributorType} from "../../types/DistributorType.sol";
-import {NftId} from "../../types/NftId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {Amount} from "../../type/Amount.sol";
+import {DistributorType} from "../../type/DistributorType.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
 interface IDistribution {
 
@@ -24,8 +25,8 @@ interface IDistribution {
         DistributorType distributorType;
         bool active;
         bytes data;
-        uint256 sumCommisions;
-        uint256 numPoliciesSold;
+        Amount commissionAmount;
+        uint32 numPoliciesSold;
     }
 
     struct ReferralInfo {