@etherisc/gif-next 0.0.2-ffa91a6-022 → 3.0.0-0fefe0d-162

package/contracts/instance/ProductStore.sol

@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+
+import {IComponents} from "./module/IComponents.sol";
+import {IInstance} from "./IInstance.sol";
+import {IPolicy} from "./module/IPolicy.sol";
+import {IRisk} from "./module/IRisk.sol";
+
+import {BalanceStore} from "./base/BalanceStore.sol";
+import {BaseStore} from "./BaseStore.sol";
+import {Blocknumber} from "../type/Blocknumber.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {Key32} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectCounter} from "./base/ObjectCounter.sol";
+import {ObjectLifecycle} from "./base/ObjectLifecycle.sol";
+import {ObjectType, FEE, POLICY, PREMIUM, PRODUCT} from "../type/ObjectType.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {StateId, KEEP_STATE} from "../type/StateId.sol";
+
+
+contract ProductStore is
+    AccessManagedUpgradeable, 
+    BalanceStore,
+    BaseStore,
+    ObjectCounter,
+    ObjectLifecycle
+{
+    event LogProductStoreProductInfoCreated(NftId productNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreProductInfoUpdated(NftId productNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreFeeInfoCreated(NftId productNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreFeeInfoUpdated(NftId productNftId, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreRiskInfoCreated(RiskId riskId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreRiskInfoUpdated(RiskId riskId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStorePolicyInfoCreated(NftId policyNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStorePolicyInfoUpdated(NftId policyNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStorePremiumInfoCreated(NftId policyNftId, StateId state, address createdBy, address txOrigin);
+    event LogProductStorePremiumInfoUpdated(NftId policyNftId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStoreClaimInfoCreated(NftId policyNftId, ClaimId claimId, StateId state, address createdBy, address txOrigin);
+    event LogProductStoreClaimInfoUpdated(NftId policyNftId, ClaimId claimId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogProductStorePayoutInfoCreated(NftId policyNftId, PayoutId payoutId, StateId state, address createdBy, address txOrigin);
+    event LogProductStorePayoutInfoUpdated(NftId policyNftId, PayoutId payoutId, StateId oldState, StateId newState, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+
+    mapping(Key32 key32 => IComponents.ProductInfo) private _products;
+    mapping(Key32 key32 => IComponents.FeeInfo) private _fees;
+    mapping(Key32 key32 => IRisk.RiskInfo) private _risks;
+    mapping(Key32 key32 => IPolicy.PolicyInfo) private _policies;
+    mapping(Key32 key32 => IPolicy.PremiumInfo) private _premiums;
+    mapping(Key32 key32 => IPolicy.ClaimInfo) private _claims;
+    mapping(Key32 key32 => IPolicy.PayoutInfo) private _payouts;
+
+
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize()
+        public 
+        initializer()
+    {
+        address instance = msg.sender;
+        address authority = IInstance(instance).authority();
+
+        __AccessManaged_init(authority);
+        // double initialization, safe
+        _initializeLifecycle();
+    }
+
+
+    //--- Product -----------------------------------------------------------//
+
+    function createProduct(NftId productNftId, IComponents.ProductInfo memory info) external restricted() {
+        Key32 key = _toNftKey32(productNftId, PRODUCT());
+        _createMetadata(key);
+        _products[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreProductInfoCreated(productNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateProduct(NftId productNftId, IComponents.ProductInfo memory info, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(productNftId, PRODUCT());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _products[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreProductInfoUpdated(productNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getProductInfo(NftId productNftId) external view returns (IComponents.ProductInfo memory info) {
+        return _products[_toNftKey32(productNftId, PRODUCT())];
+    }
+
+    //--- Fee -----------------------------------------------------------//
+
+    function createFee(NftId productNftId, IComponents.FeeInfo memory info) external restricted() {
+        Key32 key = _toNftKey32(productNftId, FEE());
+        _createMetadata(key);
+        _fees[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreFeeInfoCreated(productNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    // Fee only has one state, so no change change possible
+    function updateFee(NftId productNftId, IComponents.FeeInfo memory info) external restricted() {
+        Key32 key = _toNftKey32(productNftId, FEE());
+        (Blocknumber lastUpdatedIn,) = _updateState(key, KEEP_STATE());
+        _fees[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreFeeInfoUpdated(productNftId, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getFeeInfo(NftId productNftId) external view returns (IComponents.FeeInfo memory info) {
+        return _fees[_toNftKey32(productNftId, FEE())];
+    }
+
+    //--- Risk --------------------------------------------------------------//
+    function createRisk(RiskId riskId, IRisk.RiskInfo memory info) external restricted() {
+        Key32 key = riskId.toKey32();
+        _createMetadata(key);
+        _risks[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRiskInfoCreated(riskId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateRisk(RiskId riskId, IRisk.RiskInfo memory info, StateId newState) external restricted() {
+        Key32 key = riskId.toKey32();
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _risks[key] = info;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRiskInfoUpdated(riskId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updateRiskState(RiskId riskId, StateId newState) external restricted() {
+        // _updateState(riskId.toKey32(), newState);
+        Key32 key = riskId.toKey32();
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreRiskInfoUpdated(riskId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getRiskInfo(RiskId riskId) external view returns (IRisk.RiskInfo memory info) {
+        return _risks[riskId.toKey32()];
+    }
+
+    //--- Application (Policy) ----------------------------------------------//
+
+    function createApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy) external restricted() {
+        _registerBalanceTarget(applicationNftId);
+        Key32 key = _toNftKey32(applicationNftId, POLICY());
+        _createMetadata(key);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoCreated(applicationNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateApplication(NftId applicationNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(applicationNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(applicationNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updateApplicationState(NftId applicationNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(applicationNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(applicationNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    //--- Policy ------------------------------------------------------------//
+
+    function updatePolicy(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updatePolicyClaims(NftId policyNftId, IPolicy.PolicyInfo memory policy, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _policies[key] = policy;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updatePolicyState(NftId policyNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, POLICY());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePolicyInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getPolicyInfo(NftId policyNftId) external view returns (IPolicy.PolicyInfo memory policy) {
+        return _policies[_toNftKey32(policyNftId, POLICY())];
+    }
+
+    //--- Premium (Policy) ----------------------------------------------//
+
+    function createPremium(NftId policyNftId, IPolicy.PremiumInfo memory premium) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, PREMIUM());
+        _createMetadata(key);
+        _premiums[key] = premium;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePremiumInfoCreated(policyNftId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updatePremiumState(NftId policyNftId, StateId newState) external restricted() {
+        Key32 key = _toNftKey32(policyNftId, PREMIUM());
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePremiumInfoUpdated(policyNftId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getPremiumInfo(NftId policyNftId) external view returns (IPolicy.PremiumInfo memory premium) {
+        return _premiums[_toNftKey32(policyNftId, PREMIUM())];
+    }
+
+    //--- Claim -------------------------------------------------------------//
+
+    function createClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim) external restricted() {
+        Key32 key = _toClaimKey32(policyNftId, claimId);
+        _createMetadata(key);
+        _claims[key] = claim;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreClaimInfoCreated(policyNftId, claimId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updateClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim, StateId newState) external restricted() {
+        Key32 key = _toClaimKey32(policyNftId, claimId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _claims[key] = claim;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreClaimInfoUpdated(policyNftId, claimId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updateClaimState(NftId policyNftId, ClaimId claimId, StateId newState) external restricted() {
+        Key32 key = _toClaimKey32(policyNftId, claimId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStoreClaimInfoUpdated(policyNftId, claimId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getClaimInfo(NftId policyNftId, ClaimId claimId) external view returns (IPolicy.ClaimInfo memory claim) {
+        return _claims[_toClaimKey32(policyNftId, claimId)];
+    }
+
+    //--- Payout ------------------------------------------------------------//
+
+    function createPayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout) external restricted() {
+        Key32 key = _toPayoutKey32(policyNftId, payoutId);
+        _createMetadata(key);
+        _payouts[key] = payout;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePayoutInfoCreated(policyNftId, payoutId, getState(key), msg.sender, tx.origin);
+    }
+
+    function updatePayout(NftId policyNftId, PayoutId payoutId, IPolicy.PayoutInfo memory payout, StateId newState) external restricted() {
+        Key32 key = _toPayoutKey32(policyNftId, payoutId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        _payouts[key] = payout;
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePayoutInfoUpdated(policyNftId, payoutId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function updatePayoutState(NftId policyNftId, PayoutId payoutId, StateId newState) external restricted() {
+        Key32 key = _toPayoutKey32(policyNftId, payoutId);
+        (Blocknumber lastUpdatedIn, StateId oldState) = _updateState(key, newState);
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogProductStorePayoutInfoUpdated(policyNftId, payoutId, oldState, newState, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+    function getPayoutInfo(NftId policyNftId, PayoutId payoutId) external view returns (IPolicy.PayoutInfo memory payout) {
+        return _payouts[_toPayoutKey32(policyNftId, payoutId)];
+    }
+
+    //--- 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/RiskSet.sol

@@ -19,7 +19,6 @@ contract RiskSet is
     event LogRiskSetRiskAdded(NftId productNftId, RiskId riskId);
     event LogRiskSetRiskActive(NftId poolNftId,  RiskId riskId);
     event LogRiskSetRiskPaused(NftId poolNftId,  RiskId riskId);
-    event LogRiskSetRiskArchived(NftId poolNftId,  RiskId riskId);
 
     error ErrorRiskSetRiskLocked(RiskId riskId, NftId policyNftId); 
     error ErrorRiskSetRiskUnknown(RiskId riskId);
@@ -73,7 +72,7 @@ contract RiskSet is
     }
 
     /// @dev Applications linked to paused/archived risks may not be underwritten
-    function pause(RiskId riskId) external restricted() {
+    function deactivate(RiskId riskId) external restricted() {
         NftId productNftId = ObjectSetHelperLib.getProductNftId(_instanceAddress, riskId);
         _deactivate(productNftId, riskId.toKey32());
         emit LogRiskSetRiskPaused(productNftId, riskId);
@@ -92,6 +91,15 @@ contract RiskSet is
         }
     }
 
+    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);
     }

package/contracts/instance/TargetNames.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+string constant INSTANCE_TARGET_NAME = "Instance";
+string constant INSTANCE_ADMIN_TARGET_NAME = "InstanceAdmin";
+string constant INSTANCE_STORE_TARGET_NAME = "InstanceStore";
+string constant PRODUCT_STORE_TARGET_NAME = "ProductStore";
+string constant BUNDLE_SET_TARGET_NAME = "BundleSet";
+string constant RISK_SET_TARGET_NAME = "RiskSet";
+

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/ObjectLifecycle.sol

@@ -44,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 {
@@ -69,6 +66,7 @@ contract ObjectLifecycle is
         setStateTransition(CLAIM(), SUBMITTED(), CONFIRMED());
         setStateTransition(CLAIM(), SUBMITTED(), DECLINED());
         setStateTransition(CLAIM(), CONFIRMED(), CLOSED());
+        setStateTransition(CLAIM(), CONFIRMED(), CANCELLED());
     }
 
     function _setupPayoutLifecycle() private {
@@ -79,9 +77,7 @@ contract ObjectLifecycle is
 
     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 {

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,8 +1,6 @@
 // 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";
@@ -12,12 +10,14 @@ import {UFixed} from "../../type/UFixed.sol";
 interface IComponents {
 
     struct ComponentInfo {
+        // slot 0
         string name; // component name (needs to be unique per instance)
+        // slot 1
         TokenHandler tokenHandler;
-        bytes data; // will hold component type specific additional info (eg encoded pool info)
     }
 
     struct ProductInfo {
+        // 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
@@ -25,26 +25,36 @@ interface IComponents {
         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 {
+        // slot 0
         Amount maxBalanceAmount; // max balance amount allowed for pool
+        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 
-        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
-        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
     }
 }

package/contracts/instance/module/IDistribution.sol

@@ -1,7 +1,6 @@
 // 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";
@@ -11,33 +10,44 @@ import {UFixed} from "../../type/UFixed.sol";
 interface IDistribution {
 
     struct DistributorTypeInfo {
-        string name;
-        NftId distributionNftId;
+        // slot 0
         UFixed minDiscountPercentage;
+        NftId distributionNftId;
+        // slot 1
         UFixed maxDiscountPercentage;
-        UFixed commissionPercentage;
         uint32 maxReferralCount;
         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 {
+        // 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;
     }
 

package/contracts/instance/module/IPolicy.sol

@@ -12,29 +12,38 @@ import {Timestamp} from "../../type/Timestamp.sol";
 interface IPolicy {
 
     struct PremiumInfo {
+        // slot 0
         // premium splitting per target wallet
         Amount productFeeAmount;
         Amount distributionFeeAndCommissionAmount;
+        // slot 1
         Amount poolPremiumAndFeeAmount;
 
         // detailed positions
         // this is the net premium calculated by the product 
         Amount netPremiumAmount;
+        // slot 2
         // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
         Amount fullPremiumAmount;
         // effective premium = fullPremium - discount 
         Amount premiumAmount;
+        // slot 3
         Amount productFeeFixAmount;
         Amount poolFeeFixAmount;
+        // slot 4
         Amount bundleFeeFixAmount;
         Amount distributionFeeFixAmount;
+        // slot 5
         Amount productFeeVarAmount;
         Amount poolFeeVarAmount;
+        // slot 6
         Amount bundleFeeVarAmount;
         Amount distributionFeeVarAmount;
+        // slot 7
         Amount 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)
         Amount distributionOwnerFeeVarAmount;
+        // slot 8
         // this value is based on distributor type referenced in the referral 
         Amount commissionAmount;
         // this is based on referral used
@@ -43,43 +52,54 @@ interface IPolicy {
 
     /// @dev policy data for the full policy lifecycle
     struct PolicyInfo {
-        // application data, no changes after applying for a policy
+        // slot 0
         NftId productNftId;
         NftId bundleNftId;
-        ReferralId referralId;
         RiskId riskId;
+        // slot 1
         Amount sumInsuredAmount;
         Amount premiumAmount; // expected premium at application time
-        Seconds lifetime;
-        bytes applicationData;
-        // policy data that may change during the lifecycle
-        bytes processData;
+        ReferralId referralId;
+        // slot 2
         uint16 claimsCount;
         uint16 openClaimsCount;
         Amount claimAmount; // sum of confirmed claim amounts (max = sum insured amount)
         Amount payoutAmount; // sum of payouts (max = sum confirmed claim amountst)
+        // slot 3
         Timestamp activatedAt; // time of underwriting
+        Seconds lifetime;
         Timestamp expiredAt; // no new claims (activatedAt + lifetime)
         Timestamp closedAt; // no locked capital (or declinedAt)
+        // slot 4
+        bytes applicationData;
+        // slot 5
+        bytes processData;
     }
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct ClaimInfo {
+        // slot 0
         Amount claimAmount;
         Amount paidAmount;
+        Timestamp closedAt; // payment of confirmed claim amount (or declinedAt)
         uint24 payoutsCount;
+        // slot 1
         uint24 openPayoutsCount;
+        // slot 2
         bytes submissionData; // use case specific claim submission data, no changes after submitting the claim
+        // slot 3
         bytes processData; // use case specific data that may include information supporting confirm or decline
-        Timestamp closedAt; // payment of confirmed claim amount (or declinedAt)
     }
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct PayoutInfo {
+        // slot 0
         ClaimId claimId;
         Amount amount;
+        Timestamp paidAt; // timestamp for actual payout
+        // slot 1
         address beneficiary; // for address(0) beneficiary is policy nft owner
+        // slot 2
         bytes data; // use case specific supporting data
-        Timestamp paidAt; // timestamp for actual payout
     }
 }

package/contracts/instance/module/IRisk.sol

@@ -7,8 +7,10 @@ import {Timestamp} from "../../type/Timestamp.sol";
 interface IRisk {
 
     struct RiskInfo {
+        // slot 0
         NftId productNftId;
         Timestamp createdAt;
+        // slot 1
         bytes data;
     }
 }