@etherisc/gif-next 0.0.2-e922e07-736 → 0.0.2-e9a637d-547

package/contracts/instance/InstanceStore.sol

@@ -0,0 +1,219 @@
+// 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 "../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 {IRegistry} from "../registry/IRegistry.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(Key32 distributorKey, IDistribution.DistributorTypeInfo memory info) external restricted() {
+        create(distributorKey, abi.encode(info));
+    }
+
+    function updateDistributorType(Key32 distributorKey, IDistribution.DistributorTypeInfo memory info, StateId newState) external restricted() {
+        update(distributorKey, abi.encode(info), newState);
+    }
+
+    function updateDistributorTypeState(Key32 distributorKey, StateId newState) external restricted() {
+        updateState(distributorKey, newState);
+    }
+
+    //--- Distributor -------------------------------------------------------//
+    function createDistributor(NftId nftId, IDistribution.DistributorInfo memory info) external restricted() {
+        create(toDistributorKey32(nftId), abi.encode(info));
+    }
+
+    function updateDistributor(NftId nftId, IDistribution.DistributorInfo memory info, StateId newState) external restricted() {
+        update(toDistributorKey32(nftId), abi.encode(info), newState);
+    }
+
+    function updateDistributorState(NftId nftId, StateId newState) external restricted() {
+        updateState(toDistributorKey32(nftId), newState);
+    }
+
+    //--- Referral ----------------------------------------------------------//
+    function createReferral(Key32 referralKey, IDistribution.ReferralInfo memory referralInfo) external restricted() {
+        create(referralKey, abi.encode(referralInfo));
+    }
+
+    function updateReferral(Key32 referralKey, IDistribution.ReferralInfo memory referralInfo, StateId newState) external restricted() {
+        update(referralKey, abi.encode(referralInfo), newState);
+    }
+
+    function updateReferralState(Key32 referralKey, StateId newState) external restricted() {
+        updateState(referralKey, newState);
+    }
+
+    //--- Bundle ------------------------------------------------------------//
+    function createBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle) external restricted() {
+        create(toBundleKey32(bundleNftId), abi.encode(bundle));
+    }
+
+    function updateBundle(NftId bundleNftId, IBundle.BundleInfo memory bundle, StateId newState) external restricted() {
+        update(toBundleKey32(bundleNftId), abi.encode(bundle), newState);
+    }
+
+    function updateBundleState(NftId bundleNftId, StateId newState) external restricted() {
+        updateState(toBundleKey32(bundleNftId), 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(toPolicyKey32(applicationNftId), abi.encode(policy));
+    }
+
+    function updateApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        update(toPolicyKey32(applicationNftId), abi.encode(policy), newState);
+    }
+
+    function updateApplicationState(NftId applicationNftId, StateId newState) external restricted() {
+        updateState(toPolicyKey32(applicationNftId), newState);
+    }
+
+    //--- Policy ------------------------------------------------------------//
+    function updatePolicy(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        update(toPolicyKey32(policyNftId), abi.encode(policy), newState);
+    }
+
+    function updatePolicyState(NftId policyNftId, StateId newState) external restricted() {
+        updateState(toPolicyKey32(policyNftId), newState);
+    }
+
+    //--- Claim -------------------------------------------------------------//
+    function createClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim) external restricted() {
+        create(toPolicyKey32(policyNftId), abi.encode(claim));
+    }
+
+    function updateClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim, StateId newState) external restricted() {
+        update(toPolicyKey32(policyNftId), abi.encode(claim), newState);
+    }
+
+    function updateClaimState(NftId policyNftId, ClaimId claimId, StateId newState) external restricted() {
+        updateState(toPolicyKey32(policyNftId), newState);
+    }
+
+    //--- Payout ------------------------------------------------------------//
+    function createPayout(NftId policyNftId, NumberId payoutId, IPolicy.PayoutInfo memory payout) external restricted() {
+        create(toPolicyKey32(policyNftId), abi.encode(payout));
+    }
+
+    function updatePayout(NftId policyNftId, NumberId payoutId, IPolicy.PayoutInfo memory payout, StateId newState) external restricted() {
+        update(toPolicyKey32(policyNftId), abi.encode(payout), newState);
+    }
+
+    function updatePayoutState(NftId policyNftId, StateId newState) external restricted() {
+        updateState(toPolicyKey32(policyNftId), newState);
+    }
+
+    //--- internal view/pure functions --------------------------------------//
+    function _toNftKey32(NftId nftId, ObjectType objectType) internal pure returns (Key32) {
+        return nftId.toKey32(objectType);
+    }
+
+    function toBundleKey32(NftId bundleNftId) public pure returns (Key32) {
+        return bundleNftId.toKey32(BUNDLE());
+    }
+
+    function toPolicyKey32(NftId policyNftId) public pure returns (Key32) {
+        return policyNftId.toKey32(POLICY());
+    }
+
+    function toDistributionKey32(NftId distNftId) public pure returns (Key32) {
+        return distNftId.toKey32(DISTRIBUTION());
+    }
+
+    function toDistributorTypeKey32(NftId distNftId) public pure returns (Key32) {
+        return distNftId.toKey32(DISTRIBUTOR_TYPE());
+    }
+
+    function toDistributorKey32(NftId distNftId) public pure returns (Key32) {
+        return distNftId.toKey32(DISTRIBUTOR());
+    }
+}

package/contracts/instance/ObjectManager.sol

@@ -24,18 +24,16 @@ contract ObjectManager is
     IInstance internal _instance; // store instance address -> more flexible, instance may not be registered during ObjectManager initialization
 
     /// @dev call to initialize MUST be made in the same transaction as cloning of the contract
-    function initialize(
-        address authority,
-        address registry,
-        address instance
-    )
+    function initialize(address instanceAddress) 
+        initializer
         external 
     {
-        initialize(authority, registry);
+        IInstance instance = IInstance(instanceAddress);
+        initialize(instance.authority(), instance.getRegistryAddress());
 
-        _instance = IInstance(instance);
+        _instance = instance;
         
-        emit LogObjectManagerInitialized(instance);
+        emit LogObjectManagerInitialized(instanceAddress);
     }
 
     function getInstance() external view returns (IInstance) {

package/contracts/instance/base/ComponentService.sol

@@ -16,7 +16,6 @@ import {InstanceAccessManager} from "../InstanceAccessManager.sol";
 
 abstract contract ComponentService is Service {
 
-    error ErrorComponentServiceAlreadyRegistered(address component, NftId nftId);
     error ErrorComponentServiceNotComponent(address component);
     error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
     error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
@@ -33,13 +32,15 @@ abstract contract ComponentService is Service {
     // view functions
 
     function getRegistryService() public view virtual returns (IRegistryService) {
-        address service = getRegistry().getServiceAddress(REGISTRY(), getMajorVersion());
-        return IRegistryService(service);
+        return IRegistryService(_getServiceAddress(REGISTRY()));
     }
 
     function getInstanceService() public view returns (InstanceService) {
-        address service = getRegistry().getServiceAddress(INSTANCE(), getMajorVersion());
-        return InstanceService(service);
+        return InstanceService(_getServiceAddress(INSTANCE()));
+    }
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
     }
 
     // internal functions
@@ -60,12 +61,6 @@ abstract contract ComponentService is Service {
         // component may only be registerd by initial owner of component
         owner = msg.sender;
 
-        // check component has not already been registerd
-        NftId compoentNftId = getRegistry().getNftId(componentAddress);
-        if(compoentNftId.gtz()) {
-            revert ErrorComponentServiceAlreadyRegistered(componentAddress, compoentNftId);
-        }
-
         // check this is a component
         component = IComponent(componentAddress);
         if(!component.supportsInterface(type(IComponent).interfaceId)) {
@@ -87,48 +82,40 @@ abstract contract ComponentService is Service {
         // check instance has assigned required role to owner
         instanceNftId = componentInfo.parentNftId;
         instance = _getInstance(instanceNftId);
-        bool hasRole = getInstanceService().hasRole(
-            owner, 
-            requiredRole, 
-            address(instance));
-
-        if(!hasRole) {
+        if(!instance.getInstanceAccessManager().hasRole(requiredRole, owner)) {
             revert ErrorComponentServiceExpectedRoleMissing(instanceNftId, requiredRole, owner);
         }
     }
 
     // internal view functions
 
-    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
-        IRegistry.ObjectInfo memory instanceInfo = getRegistry().getObjectInfo(instanceNftId);
-        return IInstance(instanceInfo.objectAddress);
-    }
-
     function _getAndVerifyComponentInfoAndInstance(
-        //address component,
         ObjectType expectedType
     )
         internal
         view
         returns(
+            NftId nftId,
             IRegistry.ObjectInfo memory info, 
             IInstance instance
         )
     {
         IRegistry registry = getRegistry();
-        //TODO redundant check -> just check type
-        //NftId componentNftId = registry.getNftId(component); 
-        //require(componentNftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
 
         info = registry.getObjectInfo(msg.sender);
         require(info.objectType == expectedType, "OBJECT_TYPE_INVALID");
 
-        address instanceAddress = registry.getObjectInfo(info.parentNftId).objectAddress;
-        instance = IInstance(instanceAddress);
+        nftId = info.nftId;
+        instance = _getInstance(info.parentNftId);
 
-        InstanceAccessManager accessManager = InstanceAccessManager(instance.authority());
-        if (accessManager.isTargetLocked(info.objectAddress)) {
+        if (instance.getInstanceAccessManager().isTargetLocked(info.objectAddress)) {
             revert IAccess.ErrorIAccessTargetLocked(info.objectAddress);
         }
     }
+
+    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            getRegistry().getObjectInfo(
+                instanceNftId).objectAddress);
+    }
 }

package/contracts/instance/base/KeyValueStore.sol

@@ -5,7 +5,7 @@ import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blockn
 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 {StateId, ACTIVE, KEEP_STATE} from "../../types/StateId.sol";
 import {Timestamp, TimestampLib} from "../../types/Timestamp.sol";
 
 import {Lifecycle} from "./Lifecycle.sol";
@@ -79,16 +79,21 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         // update data
         _value[key32].data = data;
 
-        // update metadata (and state)
+        // update state 
+        if(state != KEEP_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();
 
         // create log entries
         // solhint-disable avoid-tx-origin
-        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
         emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
         // solhing-enable
     }
@@ -134,6 +139,9 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         StateId stateOld = metadata.state;
         require(stateOld.gtz(), "ERROR:KVS-041:NOT_EXISTING");
 
+        // ensure state transistion is valid
+        checkTransition(metadata.objectType, stateOld, state);
+
         // update metadata (and state)
         address updatedBy = msg.sender;
         Blocknumber lastUpdatedIn = metadata.updatedIn;
@@ -143,7 +151,7 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
 
         // create log entry
         // solhint-disable-next-line avoid-tx-origin
-        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function exists(Key32 key32) public view returns (bool) {

package/contracts/instance/base/Lifecycle.sol

@@ -1,19 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 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 {ILifecycle} from "./ILifecycle.sol";
 
-contract Lifecycle is ILifecycle {
+contract Lifecycle is
+    Initializable,
+    ILifecycle
+{
     mapping(ObjectType objectType => StateId initialState)
         private _initialState;
 
     mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
         private _isValidTransition;
 
-    constructor() {
+    function initializeLifecycle()
+        public
+        onlyInitializing
+    {
         _setupBundleLifecycle();
         _setupComponentLifecycle();
         _setupPolicyLifecycle();
@@ -78,6 +86,7 @@ contract Lifecycle is ILifecycle {
     function _setupBundleLifecycle() internal {
         _initialState[BUNDLE()] = ACTIVE();
         _isValidTransition[BUNDLE()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[BUNDLE()][ACTIVE()][CLOSED()] = true;
         _isValidTransition[BUNDLE()][PAUSED()][ACTIVE()] = true;
         _isValidTransition[BUNDLE()][PAUSED()][CLOSED()] = true;
     }

package/contracts/instance/module/IAccess.sol

@@ -8,40 +8,47 @@ import {Timestamp} from "../../types/Timestamp.sol";
 
 interface IAccess {
 
+    enum Type {
+        NotInitialized,
+        Core,
+        Gif,
+        Custom        
+    }
+
     struct RoleInfo {
         ShortString name;
-        bool isCustom;
-        bool isLocked;
+        Type rtype;
+        //bool isLocked;
+        RoleId admin;
         Timestamp createdAt;
         Timestamp updatedAt;
     }
 
     struct TargetInfo {
         ShortString name;
-        bool isCustom;
+        Type ttype;
         bool isLocked;
         Timestamp createdAt;
         Timestamp updatedAt;
     }
 
-    error ErrorIAccessRoleIdInvalid(RoleId roleId);
+    error ErrorIAccessCallerIsNotRoleAdmin(address caller, RoleId roleId);
+
+    error ErrorIAccessRoleIdDoesNotExist(RoleId roleId);
     error ErrorIAccessRoleIdTooBig(RoleId roleId);
     error ErrorIAccessRoleIdTooSmall(RoleId roleId);
-    error ErrorIAccessRoleIdAlreadyExists(RoleId roleId, ShortString name);
-    error ErrorIAccessRoleIdNotActive(RoleId roleId);
+    error ErrorIAccessRoleIdExists(RoleId roleId);
     error ErrorIAccessRoleNameEmpty(RoleId roleId);
-    error ErrorIAccessRoleNameNotUnique(RoleId roleId, ShortString name);
-    error ErrorIAccessRoleInvalidUpdate(RoleId roleId, bool isCustom);
-    error ErrorIAccessRoleIsCustomIsImmutable(RoleId roleId, bool isCustom, bool isCustomExisting);
-    error ErrorIAccessGrantNonexstentRole(RoleId roleId);
-    error ErrorIAccessRevokeNonexstentRole(RoleId roleId); 
-    error ErrorIAccessRenounceNonexstentRole(RoleId roleId);
+    error ErrorIAccessRoleNameExists(RoleId roleId, RoleId existingRoleId, ShortString name);
+    error ErrorIAccessRoleTypeInvalid(RoleId roleId, Type rtype);
 
     error ErrorIAccessTargetAddressZero();
-    error ErrorIAccessTargetDoesNotExist(ShortString name);
-    error ErrorIAccessTargetAddressDoesNotExist(address target);
+    error ErrorIAccessTargetDoesNotExist(address target);
     error ErrorIAccessTargetExists(address target, ShortString name);
+    error ErrorIAccessTargetTypeInvalid(address target, Type ttype);
     error ErrorIAccessTargetNameEmpty(address target);
     error ErrorIAccessTargetNameExists(address target, address existingTarget, ShortString name);
     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 {Amount} from "../../types/Amount.sol";
 import {NftId} from "../../types/NftId.sol";
 import {Fee} from "../../types/Fee.sol";
 import {Seconds} from "../../types/Seconds.sol";
 import {Timestamp} from "../../types/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

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount} from "../../types/Amount.sol";
+import {Fee} from "../../types/Fee.sol";
+import {NftId} from "../../types/NftId.sol";
+import {RoleId} from "../../types/RoleId.sol";
+import {TokenHandler} from "../../shared/TokenHandler.sol";
+import {UFixed} from "../../types/UFixed.sol";
+
+interface IComponents {
+
+    struct ComponentInfo {
+        string name; // component name (needs to be unique per instance)
+        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
+        // TODO maxCapitalAmount -> maxBalanceAmount
+        uint256 maxCapitalAmount; // max capital amount allowed for pool
+        uint256 balanceAmount; // current pool balance (accounting view)
+        uint256 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 
+        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
+        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+}

package/contracts/instance/module/ISetup.sol

@@ -5,10 +5,12 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 
 import {Fee} from "../../types/Fee.sol";
 import {NftId} from "../../types/NftId.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {RoleId} from "../../types/RoleId.sol";
 import {TokenHandler} from "../../shared/TokenHandler.sol";
+import {UFixed} from "../../types/UFixed.sol";
 
 interface ISetup {
+
     struct ProductSetupInfo {
         IERC20Metadata token;
         TokenHandler tokenHandler;
@@ -28,19 +30,4 @@ interface ISetup {
         address wallet;
         uint256 sumDistributionOwnerFees;
     }
-
-    struct PoolSetupInfo {
-        NftId productNftId;
-        TokenHandler tokenHandler;
-        uint256 maxCapitalAmount; // max capital amount allowed for pool
-        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 
-        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
-        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
-        Fee poolFee; // pool fee on net premium
-        Fee stakingFee; // pool fee on staked capital from investor
-        Fee performanceFee; // pool fee on profits from capital investors
-        address wallet;
-    }
 }