@etherisc/gif-next 0.0.2-d372e08-980 → 0.0.2-d3d5a3c-236

package/contracts/instance/InstanceServiceManager.sol

@@ -7,7 +7,7 @@ import {ProxyManager} from "../shared/ProxyManager.sol";
 import {InstanceService} from "./InstanceService.sol";
 import {Registry} from "../registry/Registry.sol";
 import {RegistryService} from "../registry/RegistryService.sol";
-import {VersionLib} from "../types/Version.sol";
+import {REGISTRY} from "../types/ObjectType.sol";
 
 contract InstanceServiceManager is ProxyManager {
 
@@ -17,7 +17,7 @@ contract InstanceServiceManager is ProxyManager {
     constructor(
         address registryAddress
     )
-        ProxyManager()
+        ProxyManager(registryAddress)
     {
         InstanceService instSrv = new InstanceService();
         // bytes memory initCode = type(InstanceService).creationCode;
@@ -28,10 +28,10 @@ contract InstanceServiceManager is ProxyManager {
 
         _instanceService = InstanceService(address(versionable));
 
-        Registry registry = Registry(registryAddress);
-        address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
-        RegistryService registryService = RegistryService(registryServiceAddress);
-        // TODO this must have a role or own nft to register service
+        // TODO `this` must have a role or own nft to register service
+        //Registry registry = Registry(registryAddress);
+        //address registryServiceAddress = registry.getServiceAddress(REGISTRY(), _instanceService.getMajorVersion());
+        //RegistryService registryService = RegistryService(registryServiceAddress);
         //registryService.registerService(_instanceService);
         // RegistryService registryService = _instanceService.getRegistryService();
 
@@ -40,9 +40,6 @@ contract InstanceServiceManager is ProxyManager {
         //_linkToNftOwnable(
         //    address(registryAddress),
         //    address(_instanceService));
-
-        // implies that after this constructor call only upgrade functionality is available
-        _isDeployed = true;
     }
 
     //--- view functions ----------------------------------------------------//

package/contracts/instance/ObjectManager.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+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";
+
+contract ObjectManager is
+    Cloneable
+{
+
+    event LogObjectManagerInitialized(address instance);
+
+    error ErrorObjectManagerNftIdInvalid(NftId instanceNftId);
+    error ErrorObjectManagerAlreadyAdded(NftId componentNftId, NftId objectNftId);
+
+    mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _activeObjects;
+    mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _allObjects;
+    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 instanceAddress) 
+        initializer
+        external 
+    {
+        IInstance instance = IInstance(instanceAddress);
+        initialize(instance.authority(), instance.getRegistryAddress());
+
+        _instance = instance;
+        
+        emit LogObjectManagerInitialized(instanceAddress);
+    }
+
+    function getInstance() external view returns (IInstance) {
+        return _instance;
+    }
+
+    function _add(NftId componentNftId, NftId objectNftId) internal {
+        LibNftIdSet.Set storage allSet = _allObjects[componentNftId];
+        LibNftIdSet.Set storage activeSet = _activeObjects[componentNftId];
+
+        LibNftIdSet.add(allSet, objectNftId);
+        LibNftIdSet.add(activeSet, objectNftId);
+    }
+
+    function _activate(NftId componentNftId, NftId objectNftId) internal {
+        LibNftIdSet.add(_activeObjects[componentNftId], objectNftId);
+    }
+
+    function _deactivate(NftId componentNftId, NftId objectNftId) internal {
+        LibNftIdSet.remove(_activeObjects[componentNftId], objectNftId);
+    }
+
+    function _objects(NftId componentNftId) internal view returns (uint256) {
+        return LibNftIdSet.size(_allObjects[componentNftId]);
+    }
+
+    function _contains(NftId componentNftId, NftId objectNftId) internal view returns (bool) {
+        return LibNftIdSet.contains(_allObjects[componentNftId], objectNftId);
+    }
+
+    function _getObject(NftId componentNftId, uint256 idx) internal view returns (NftId) {
+        return LibNftIdSet.getElementAt(_allObjects[componentNftId], idx);
+    }
+
+    function _activeObjs(NftId componentNftId) internal view returns (uint256)  {
+        return LibNftIdSet.size(_activeObjects[componentNftId]);
+    }
+
+    function _isActive(NftId componentNftId, NftId objectNftId) internal view returns (bool) {
+        return LibNftIdSet.contains(_activeObjects[componentNftId], objectNftId);
+    }
+
+    function _getActiveObject(NftId componentNftId, uint256 idx) internal view returns (NftId) {
+        return LibNftIdSet.getElementAt(_activeObjects[componentNftId], idx);
+    }
+}

package/contracts/instance/base/ComponentService.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponent} from "../../components/IComponent.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {IAccess} from "../module/IAccess.sol";
+import {ObjectType, INSTANCE, REGISTRY} from "../../types/ObjectType.sol";
+import {NftId} from "../../types/NftId.sol";
+import {RoleId} from "../../types/RoleId.sol";
+
+import {Service} from "../../shared/Service.sol";
+import {InstanceService} from "../InstanceService.sol";
+import {InstanceAccessManager} from "../InstanceAccessManager.sol";
+
+abstract contract ComponentService is Service {
+
+    error ErrorComponentServiceNotComponent(address component);
+    error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
+    error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
+    error ErrorComponentServiceExpectedRoleMissing(NftId instanceNftId, RoleId requiredRole, address sender);
+    error ErrorComponentServiceComponentLocked(address component);
+
+    /// @dev modifier to check if caller is a registered service
+    modifier onlyService() {
+        address caller = msg.sender;
+        require(getRegistry().isRegisteredService(caller), "ERROR_NOT_SERVICE");
+        _;
+    }
+
+    // view functions
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        return IRegistryService(_getServiceAddress(REGISTRY()));
+    }
+
+    function getInstanceService() public view returns (InstanceService) {
+        return InstanceService(_getServiceAddress(INSTANCE()));
+    }
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
+    }
+
+    // internal functions
+    function _checkComponentForRegistration(
+        address componentAddress,
+        ObjectType requiredType,
+        RoleId requiredRole
+    )
+        internal
+        view
+        returns (
+            IComponent component,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        )
+    {
+        // component may only be registerd by initial owner of component
+        owner = msg.sender;
+
+        // check this is a component
+        component = IComponent(componentAddress);
+        if(!component.supportsInterface(type(IComponent).interfaceId)) {
+            revert ErrorComponentServiceNotComponent(componentAddress);
+        }
+
+        // check component is of required type
+        IRegistry.ObjectInfo memory componentInfo = component.getInitialInfo();
+        if(componentInfo.objectType != requiredType) {
+            revert ErrorComponentServiceInvalidType(componentAddress, requiredType, componentInfo.objectType);
+        }
+
+        // check msg.sender is component owner
+        address initialOwner = componentInfo.initialOwner;
+        if(owner != initialOwner) {
+            revert ErrorComponentServiceSenderNotOwner(componentAddress, componentInfo.initialOwner, owner);
+        }
+
+        // check instance has assigned required role to owner
+        instanceNftId = componentInfo.parentNftId;
+        instance = _getInstance(instanceNftId);
+        if(!instance.getInstanceAccessManager().hasRole(requiredRole, owner)) {
+            revert ErrorComponentServiceExpectedRoleMissing(instanceNftId, requiredRole, owner);
+        }
+    }
+
+    // internal view functions
+
+    function _getAndVerifyComponentInfoAndInstance(
+        ObjectType expectedType
+    )
+        internal
+        view
+        returns(
+            NftId nftId,
+            IRegistry.ObjectInfo memory info, 
+            IInstance instance
+        )
+    {
+        IRegistry registry = getRegistry();
+
+        info = registry.getObjectInfo(msg.sender);
+        require(info.objectType == expectedType, "OBJECT_TYPE_INVALID");
+
+        nftId = info.nftId;
+        instance = _getInstance(info.parentNftId);
+
+        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

@@ -1,38 +1,54 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
 
 import {RoleId} from "../../types/RoleId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
 
 interface IAccess {
+
+    enum Type {
+        NotInitialized,
+        Core,
+        Gif,
+        Custom        
+    }
+
     struct RoleInfo {
         ShortString name;
-        bool isCustom;
+        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 ErrorTargetAddressZero();
-    error ErrorTargetAlreadyExists(address target, ShortString name);
-    error ErrorTargetDoesNotExist(address target);
-    error ErrorTargetNameEmpty(address target);
-    error ErrorTargetNameExists(address target, address existingTarget, ShortString name);
-
-    error ErrorRoleIdInvalid(RoleId roleId);
-    error ErrorRoleIdTooBig(RoleId roleId);
-    error ErrorRoleIdTooSmall(RoleId roleId);
-    error ErrorRoleIdAlreadyExists(RoleId roleId, ShortString name);
-    error ErrorRoleIdNotActive(RoleId roleId);
-    error ErrorRoleNameEmpty(RoleId roleId);
-    error ErrorRoleNameNotUnique(RoleId roleId, ShortString name);
-    error ErrorRoleInvalidUpdate(RoleId roleId, bool isCustom);
-    error ErrorGrantNonexstentRole(RoleId roleId);
-    error ErrorRevokeNonexstentRole(RoleId roleId);
-    error ErrorRenounceNonexstentRole(RoleId roleId);
+    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(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,20 +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)
-        uint256 lifetime;
-        Timestamp expiredAt; // no new policies
+        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 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/IDistribution.sol

@@ -24,6 +24,8 @@ interface IDistribution {
         DistributorType distributorType;
         bool active;
         bytes data;
+        uint256 sumCommisions;
+        uint256 numPoliciesSold;
     }
 
     struct ReferralInfo {   

package/contracts/instance/module/IPolicy.sol

@@ -2,12 +2,39 @@
 pragma solidity ^0.8.20;
 
 import {NftId} from "../../types/NftId.sol";
-import {NumberId} from "../../types/NumberId.sol";
+import {ClaimId} from "../../types/ClaimId.sol";
 import {ReferralId} from "../../types/Referral.sol";
 import {RiskId} from "../../types/RiskId.sol";
+import {Seconds} from "../../types/Seconds.sol";
 import {Timestamp} from "../../types/Timestamp.sol";
 
 interface IPolicy {
+
+    struct Premium {
+        // this is the net premium calculated by the product 
+        uint256 netPremiumAmount;
+        // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
+        uint256 fullPremiumAmount;
+        // premium = fullPremium - discount
+        uint256 premiumAmount;
+        uint256 productFeeFixAmount;
+        uint256 poolFeeFixAmount;
+        uint256 bundleFeeFixAmount;
+        uint256 distributionFeeFixAmount;
+        uint256 productFeeVarAmount;
+        uint256 poolFeeVarAmount;
+        uint256 bundleFeeVarAmount;
+        uint256 distributionFeeVarAmount;
+        uint256 distributionOwnerFeeFixAmount;
+        // this is the remaining amount when the commission and discount are subtracted from the distribution fee variable part (must be at least the minDistributionOwnerFee)
+        uint256 distributionOwnerFeeVarAmount;
+        // this value is based on distributor type referenced in the referral 
+        uint256 commissionAmount;
+        // this is based on referral used
+        uint256 discountAmount;
+    }
+
+    /// @dev policy data for the full policy lifecycle
     struct PolicyInfo {
         NftId productNftId;
         NftId bundleNftId;
@@ -16,7 +43,7 @@ interface IPolicy {
         uint256 sumInsuredAmount;
         uint256 premiumAmount;
         uint256 premiumPaidAmount;
-        uint256 lifetime;
+        Seconds lifetime;
         bytes applicationData;
         bytes policyData;
         uint16 claimsCount;
@@ -37,7 +64,7 @@ interface IPolicy {
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct PayoutInfo {
-        NumberId claimId;
+        ClaimId claimId;
         uint256 amount;
         bytes data;
         Timestamp paidAt; // payoment of confirmed claim amount (or declinedAt)

package/contracts/instance/module/ISetup.sol

@@ -5,22 +5,19 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 
 import {Fee} from "../../types/Fee.sol";
 import {NftId} from "../../types/NftId.sol";
-import {LibNftIdSet} from "../../types/NftIdSet.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;
         NftId distributionNftId;
         NftId poolNftId;
-        Fee distributionFee; // default distribution fee (no referral id)
         Fee productFee; // product fee on net premium
-        Fee processingFee; // product fee on payout amounts
-        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
+        Fee processingFee; // product fee on payout amounts        
         bool isIntercepting; // intercepts nft transfers (for products)
         address wallet;
     }
@@ -28,20 +25,9 @@ interface ISetup {
     struct DistributionSetupInfo {
         NftId productNftId;
         TokenHandler tokenHandler;
-        Fee distributionFee; // default distribution fee (no referral id)
-        bool isIntercepting; // intercepts nft transfers (for distributors)
-        address wallet;
-    }
-
-    struct PoolSetupInfo {
-        NftId productNftId;
-        TokenHandler tokenHandler;
-        UFixed collateralizationLevel;
-        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
-        bool isIntercepting; // intercepts nft transfers (for bundles)
-        bool isConfirmingApplication; // confirms applications before they are underwritten
+        Fee minDistributionOwnerFee;
+        Fee distributionFee; // recalculated whenever any fee on the product/pool/dist/disttype is changed
         address wallet;
+        uint256 sumDistributionOwnerFees;
     }
 }