@etherisc/gif-next 0.0.2-ff1bf36-818 → 0.0.2-ff596ab-857

package/contracts/instance/InstanceServiceManager.sol

@@ -12,16 +12,15 @@ contract InstanceServiceManager is ProxyManager {
     /// @dev initializes proxy manager with instance service implementation
     constructor(
         address authority, 
-        address registryAddress,
+        address registry,
         bytes32 salt
     ) 
-        ProxyManager(registryAddress)
     {
-        InstanceService instSrv = new InstanceService{salt: salt}();
-        // bytes memory initCode = type(InstanceService).creationCode;
-        bytes memory data = abi.encode(registryAddress, address(this), authority);
-        IVersionable versionable = deployDetermenistic(
-            address(instSrv), 
+        InstanceService svc = new InstanceService{salt: salt}();
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
+            address(svc), 
             data,
             salt);
 

package/contracts/instance/InstanceStore.sol

@@ -7,10 +7,10 @@ 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, PRODUCT, COMPONENT, DISTRIBUTOR} from "../type/ObjectType.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} from "../type/StateId.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";
@@ -85,6 +85,17 @@ contract InstanceStore is
         _update(_toNftKey32(productNftId, PRODUCT()), abi.encode(info), newState);
     }
 
+
+    //--- Fee -----------------------------------------------------------//
+    function createFee(NftId productNftId, IComponents.FeeInfo memory info) external restricted() {
+        _create(_toNftKey32(productNftId, FEE()), 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());
+    }
+
     //--- Pool --------------------------------------------------------------//
 
     function createPool(
@@ -195,6 +206,16 @@ contract InstanceStore is
         _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));

package/contracts/instance/RiskSet.sol

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

package/contracts/instance/base/BalanceStore.sol

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

package/contracts/instance/base/ObjectCounter.sol

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

package/contracts/instance/base/ObjectLifecycle.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-import {COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT, POOL, PRODUCT, DISTRIBUTION, DISTRIBUTOR, DISTRIBUTOR_TYPE, REFERRAL} from "../../type/ObjectType.sol";
+import {COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT, POOL, PREMIUM, PRODUCT, DISTRIBUTION, DISTRIBUTOR, DISTRIBUTOR_TYPE, REFERRAL, FEE} from "../../type/ObjectType.sol";
 import {ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../../type/StateId.sol";
 import {Lifecycle} from "../../shared/Lifecycle.sol";
 
@@ -23,6 +23,7 @@ contract ObjectLifecycle is
         _setupBundleLifecycle();
         _setupComponentLifecycle();
         _setupPolicyLifecycle();
+        _setupPremiumLifecycle();
         _setupClaimLifecycle();
         _setupPayoutLifecycle();
         _setupRiskLifecycle();
@@ -43,10 +44,7 @@ contract ObjectLifecycle is
 
     function _setupBundleLifecycle() private {
         setInitialState(BUNDLE(), ACTIVE());
-        setStateTransition(BUNDLE(), ACTIVE(), PAUSED());
         setStateTransition(BUNDLE(), ACTIVE(), CLOSED());
-        setStateTransition(BUNDLE(), PAUSED(), ACTIVE());
-        setStateTransition(BUNDLE(), PAUSED(), CLOSED());
     }
 
     function _setupPolicyLifecycle() private {
@@ -57,24 +55,29 @@ contract ObjectLifecycle is
         setStateTransition(POLICY(), COLLATERALIZED(), CLOSED());
     }
 
+    function _setupPremiumLifecycle() private {
+        setInitialState(PREMIUM(), EXPECTED());
+        setStateTransition(PREMIUM(), EXPECTED(), PAID());
+    }
+
     function _setupClaimLifecycle() private {
         setInitialState(CLAIM(), SUBMITTED());
+        setStateTransition(CLAIM(), SUBMITTED(), REVOKED());
         setStateTransition(CLAIM(), SUBMITTED(), CONFIRMED());
         setStateTransition(CLAIM(), SUBMITTED(), DECLINED());
         setStateTransition(CLAIM(), CONFIRMED(), CLOSED());
+        setStateTransition(CLAIM(), CONFIRMED(), CANCELLED());
     }
 
     function _setupPayoutLifecycle() private {
         setInitialState(PAYOUT(), EXPECTED());
-        // TODO: add state cancelled
         setStateTransition(PAYOUT(), EXPECTED(), PAID());
+        setStateTransition(PAYOUT(), EXPECTED(), CANCELLED());
     }
 
     function _setupRiskLifecycle() private {
         setInitialState(RISK(), ACTIVE());
-        setStateTransition(RISK(), ACTIVE(), PAUSED());
-        setStateTransition(RISK(), PAUSED(), ACTIVE());
-        setStateTransition(RISK(), PAUSED(), ARCHIVED());
+        setStateTransition(RISK(), ACTIVE(), CLOSED());
     }
 
     function _setupRequestLifecycle() private {
@@ -93,6 +96,7 @@ contract ObjectLifecycle is
     // dummy lifecycle only
     function _setUpProductLifecycle() private {
         setInitialState(PRODUCT(), ACTIVE());
+        setInitialState(FEE(), ACTIVE());
     }
 
     // dummy lifecycles only

package/contracts/instance/base/ObjectSet.sol

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

package/contracts/instance/base/ObjectSetHelperLib.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IBundle} from "../module/IBundle.sol";
+import {IInstance} from "../IInstance.sol";
+import {IRisk} from "../module/IRisk.sol";
+import {NftId} from "../../type/NftId.sol";
+import {RiskId} from "../../type/RiskId.sol";
+
+
+library ObjectSetHelperLib {
+
+    function getRiskInfo(address instanceAddress, RiskId riskId) public view returns (IRisk.RiskInfo memory) {
+
+        return IInstance(instanceAddress).getInstanceReader().getRiskInfo(riskId);
+    }
+
+    function getProductNftId(address instanceAddress, RiskId riskId) public view returns (NftId) {
+        return getRiskInfo(instanceAddress, riskId).productNftId;
+    }
+
+    function getBundleInfo(address instanceAddress, NftId bundleNftId) public view returns (IBundle.BundleInfo memory) {
+        return IInstance(instanceAddress).getInstanceReader().getBundleInfo(bundleNftId);
+    }
+
+    function getPoolNftId(address instanceAddress, NftId bundleNftId) public view returns (NftId) {
+        return getBundleInfo(instanceAddress, bundleNftId).poolNftId;
+    }
+
+}

package/contracts/instance/module/IBundle.sol

@@ -1,20 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-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
+        // slot 0
         Timestamp activatedAt; 
         Timestamp expiredAt; // no new policies starting with this timestamp
         Timestamp closedAt; // no open policies, locked amount = 0
+        NftId poolNftId;
+        // slot 1
+        Fee fee; // bundle fee on net premium amounts
+        // slot 2
+        bytes filter; // required conditions for applications to be considered for collateralization by this bundle
     }
 }

package/contracts/instance/module/IComponents.sol

@@ -1,46 +1,62 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.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 "../../type/UFixed.sol";
 
 interface IComponents {
 
     struct ComponentInfo {
+        // slot 0
         string name; // component name (needs to be unique per instance)
-        NftId productNftId;
-        IERC20Metadata token;
+        // slot 1
         TokenHandler tokenHandler;
-        address wallet;
+        // slot 2
         bytes data; // will hold component type specific additional info (eg encoded pool info)
     }
 
     struct ProductInfo {
-        NftId distributionNftId;
-        NftId poolNftId;
+        // slot 0
+        bool isProcessingFundedClaims; // custom logic to react to pool events for funded claims
+        bool isInterceptingPolicyTransfers; // custom logic for policy nft transfers
+        bool hasDistribution; // flag to indicate if distribution is enabled
+        uint8 expectedNumberOfOracles; // expected number of oracles
+        uint8 numberOfOracles; // actual number of oracles
+        NftId poolNftId; // mandatory
+        NftId distributionNftId; // 0..1 (optional)
+        // slot 1
+        NftId [] oracleNftId; // 0..n (optional)
+    }
+
+    struct FeeInfo {
+        // slot 0
         Fee productFee; // product fee on net premium
+        // slot 1
         Fee processingFee; // product fee on payout amounts        
+        // slot 2
         Fee distributionFee; // distribution fee for sales that do not include commissions
+        // slot 3
         Fee minDistributionOwnerFee; // min fee required by distribution owner (not including commissions for distributors)
+        // slot 4
         Fee poolFee; // pool fee on net premium
+        // slot 5
         Fee stakingFee; // pool fee on staked capital from investor
+        // slot 6
         Fee performanceFee; // pool fee on profits from capital investors
     }
 
-
     struct PoolInfo {
-        RoleId bundleOwnerRole; // the required role for bundle owners
+        // slot 0
         Amount maxBalanceAmount; // max balance 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%)
+        // slot 1
         UFixed retentionLevel; // amount of collateral held in pool (default 100%)
+        bool isInterceptingBundleTransfers; // custom logic for bundle nft transfers
+        bool isProcessingConfirmedClaims; // custom logic for claims confirmation
+        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,40 +1,53 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount} from "../../type/Amount.sol";
 import {DistributorType} from "../../type/DistributorType.sol";
 import {NftId} from "../../type/NftId.sol";
+import {Seconds} from "../../type/Seconds.sol";
 import {Timestamp} from "../../type/Timestamp.sol";
 import {UFixed} from "../../type/UFixed.sol";
 
 interface IDistribution {
 
     struct DistributorTypeInfo {
-        string name;
+        // slot 0
         UFixed minDiscountPercentage;
+        NftId distributionNftId;
+        // slot 1
         UFixed maxDiscountPercentage;
-        UFixed commissionPercentage;
         uint32 maxReferralCount;
-        uint32 maxReferralLifetime;
+        Seconds maxReferralLifetime;
         bool allowSelfReferrals;
         bool allowRenewals;
+        // slot 2
+        UFixed commissionPercentage;
+        // slot 3
+        string name;                
+        // slot 4
         bytes data;
     }
 
     struct DistributorInfo {
+        // slot 0
         DistributorType distributorType;
         bool active;
-        bytes data;
         uint32 numPoliciesSold;
+        // slot 1
+        bytes data;
     }
 
-    struct ReferralInfo {   
+    struct ReferralInfo {
+        // slot 0
+        NftId distributionNftId;
         NftId distributorNftId;
-        string referralCode;
-        UFixed discountPercentage;
         uint32 maxReferrals;
         uint32 usedReferrals;
+        // slot 1
+        UFixed discountPercentage;
         Timestamp expiryAt;
+        // slot 2
+        string referralCode;
+        // slot 3
         bytes data;
     }