@etherisc/gif-next 0.0.2-fd4ee14-428 → 0.0.2-fd5f17a-625

package/contracts/product/BasicProductAuthorization.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicProduct} from "./BasicProduct.sol"; 
+import {PRODUCT} from "../type/ObjectType.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicProductAuthorization
+     is Authorization
+{
+
+     constructor(string memory componentName)
+          Authorization(componentName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          // basic component target
+          _addComponentTargetWithRole(PRODUCT()); 
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicProduct.setFees.selector, "setFees");
+
+          _authorize(functions, IInstanceLinkedComponent.withdrawFees.selector, "withdrawFees");
+     }
+}
+

package/contracts/product/ClaimService.sol

@@ -1,48 +1,22 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IRisk} from "../instance/module/IRisk.sol";
-import {IService} from "./IApplicationService.sol";
-
 import {IComponents} from "../instance/module/IComponents.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {IProductComponent} from "./IProductComponent.sol";
-import {Product} from "./Product.sol";
-import {IPoolComponent} from "../pool/IPoolComponent.sol";
-import {IDistributionComponent} from "../distribution/IDistributionComponent.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
-import {IRisk} from "../instance/module/IRisk.sol";
-import {IBundle} from "../instance/module/IBundle.sol";
-import {IProductService} from "./IProductService.sol";
-
-import {TokenHandler} from "../shared/TokenHandler.sol";
-
-import {IVersionable} from "../shared/IVersionable.sol";
-import {Versionable} from "../shared/Versionable.sol";
-
 import {Amount, AmountLib} from "../type/Amount.sol";
-import {Timestamp, TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
-import {UFixed, UFixedLib} from "../type/UFixed.sol";
-import {Blocknumber, blockNumber} from "../type/Blocknumber.sol";
-import {ObjectType, INSTANCE, PRODUCT, POOL, APPLICATION, POLICY, CLAIM, BUNDLE} from "../type/ObjectType.sol";
-import {SUBMITTED, ACTIVE, KEEP_STATE, DECLINED, CONFIRMED, CLOSED, PAID} from "../type/StateId.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
-import {ReferralId} from "../type/Referral.sol";
-import {RiskId} from "../type/RiskId.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
+import {ObjectType, CLAIM, PRODUCT, POOL} from "../type/ObjectType.sol";
+import {SUBMITTED, KEEP_STATE, DECLINED, REVOKED, CONFIRMED, CLOSED, PAID} from "../type/StateId.sol";
+import {NftId} from "../type/NftId.sol";
+import {FeeLib} from "../type/Fee.sol";
 import {StateId} from "../type/StateId.sol";
 import {ClaimId, ClaimIdLib} from "../type/ClaimId.sol";
 import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
-import {Version, VersionLib} from "../type/Version.sol";
-
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
-import {IBundleService} from "../pool/IBundleService.sol";
 import {IClaimService} from "./IClaimService.sol";
 import {IPoolService} from "../pool/IPoolService.sol";
-import {IService} from "../shared/IService.sol";
-import {Service} from "../shared/Service.sol";
 
 
 contract ClaimService is 
@@ -66,11 +40,11 @@ contract ClaimService is
             address authority
         ) = abi.decode(data, (address, address, address));
 
-        initializeService(registryAddress, authority, owner);
+        _initializeService(registryAddress, authority, owner);
 
         _poolService = IPoolService(getRegistry().getServiceAddress(POOL(), getVersion().toMajorPart()));
 
-        registerInterface(type(IClaimService).interfaceId);
+        _registerInterface(type(IClaimService).interfaceId);
     }
 
     function submit(
@@ -93,6 +67,7 @@ contract ClaimService is
             revert ErrorClaimServicePolicyNotOpen(policyNftId);
         }
 
+        // TODO check claim amount > 0
         // check policy including this claim is still within sum insured
         if(policyInfo.payoutAmount + claimAmount > policyInfo.sumInsuredAmount) {
             revert ErrorClaimServiceClaimExceedsSumInsured(
@@ -106,14 +81,14 @@ contract ClaimService is
         instance.getInstanceStore().createClaim(
             policyNftId, 
             claimId, 
-            IPolicy.ClaimInfo(
-                claimAmount,
-                AmountLib.zero(), // paidAmount
-                0, // payoutsCount
-                0, // openPayoutsCount
-                claimData, // claim submission data
-                "", // claim processing data
-                TimestampLib.zero())); // closedAt
+            IPolicy.ClaimInfo({
+                claimAmount: claimAmount,
+                paidAmount: AmountLib.zero(),
+                payoutsCount: 0,
+                openPayoutsCount: 0,
+                submissionData: claimData,
+                processData: "",
+                closedAt: TimestampLib.zero()}));
 
         // update and save policy info with instance
         policyInfo.claimsCount += 1;
@@ -140,12 +115,17 @@ contract ClaimService is
             IPolicy.PolicyInfo memory policyInfo
         ) = _verifyCallerWithPolicy(policyNftId);
 
+        // TODO add check for confirmedAmount > 0 and does not lead to exceeding sum insured
+
         // check/update claim info
         IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
         claimInfo.claimAmount = confirmedAmount;
         claimInfo.processData = data;
         instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, CONFIRMED());
 
+        // TODO test if claim results in total claim amount == sum insured amount
+        // should policy still be active it needs to automatically become expired
+
         // update and save policy info with instance
         policyInfo.claimAmount = policyInfo.claimAmount + confirmedAmount;
         instance.getInstanceStore().updatePolicyClaims(policyNftId, policyInfo, KEEP_STATE());
@@ -180,6 +160,34 @@ contract ClaimService is
         emit LogClaimServiceClaimDeclined(policyNftId, claimId);
     }
 
+
+    // TODO add test case
+    function revoke(
+        NftId policyNftId, 
+        ClaimId claimId
+    )
+        external
+        virtual
+    {
+        (
+            IInstance instance,
+            InstanceReader instanceReader,
+            IPolicy.PolicyInfo memory policyInfo
+        ) = _verifyCallerWithPolicy(policyNftId);
+
+        // check/update claim info
+        IPolicy.ClaimInfo memory claimInfo = _verifyClaim(instanceReader, policyNftId, claimId, SUBMITTED());
+        claimInfo.closedAt = TimestampLib.blockTimestamp();
+        instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, REVOKED());
+
+        // update and save policy info with instance
+        policyInfo.openClaimsCount -= 1;
+        instance.getInstanceStore().updatePolicyClaims(policyNftId, policyInfo, KEEP_STATE());
+
+        emit LogClaimServiceClaimRevoked(policyNftId, claimId);
+    }
+
+
     function close(
         NftId policyNftId, 
         ClaimId claimId
@@ -217,6 +225,30 @@ contract ClaimService is
         instance.getInstanceStore().updateClaim(policyNftId, claimId, claimInfo, CLOSED());
     }
 
+    // TODO add test
+    function createPayoutForBeneficiary(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        address beneficiary,
+        bytes memory data
+    )
+        external
+        virtual
+        returns (PayoutId payoutId)
+    {
+        if (beneficiary == address(0)) {
+            revert ErrorClaimServiceBeneficiaryIsZero(policyNftId, claimId);
+        }
+
+        return _createPayout(
+            policyNftId, 
+            claimId, 
+            amount, 
+            beneficiary,
+            data);
+    }
+
 
     function createPayout(
         NftId policyNftId, 
@@ -225,6 +257,26 @@ contract ClaimService is
         bytes memory data
     )
         external
+        virtual
+        returns (PayoutId payoutId)
+    {
+        return _createPayout(
+            policyNftId, 
+            claimId, 
+            amount, 
+            address(0), // defaults to owner of policy nft
+            data);
+    }
+
+    function _createPayout(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        address beneficiary,
+        bytes memory data
+    )
+        internal
+        virtual
         returns (PayoutId payoutId)
     {
         (
@@ -247,11 +299,12 @@ contract ClaimService is
         instance.getInstanceStore().createPayout(
             policyNftId, 
             payoutId, 
-            IPolicy.PayoutInfo(
-                payoutId.toClaimId(),
-                amount,
-                data,
-                TimestampLib.zero()));
+            IPolicy.PayoutInfo({
+                claimId: payoutId.toClaimId(),
+                amount: amount,
+                beneficiary: beneficiary,
+                data: data,
+                paidAt: TimestampLib.zero()}));
 
         // update and save claim info with instance
         claimInfo.payoutsCount += 1;
@@ -319,20 +372,28 @@ contract ClaimService is
         // transfer payout token and fee
         (
             Amount netPayoutAmount,
+            Amount processingFeeAmount,
             address beneficiary
-        ) = _transferPayoutAmount(
+        ) = _calculatePayoutAmount(
             instanceReader,
             policyNftId,
             policyInfo,
             payoutInfo);
 
-        // TODO callback IPolicyHolder
+        emit LogClaimServicePayoutProcessed(policyNftId, payoutId, payoutAmount, beneficiary, netPayoutAmount, processingFeeAmount);
+
+        {
+            NftId poolNftId = getRegistry().getObjectInfo(policyInfo.bundleNftId).parentNftId;
+            IComponents.ComponentInfo memory poolInfo = instanceReader.getComponentInfo(poolNftId);
+            poolInfo.tokenHandler.distributeTokens(poolInfo.wallet, beneficiary, netPayoutAmount);
+
+            // TODO add 2nd token tx if processingFeeAmount > 0
+        }
 
-        emit LogClaimServicePayoutProcessed(policyNftId, payoutId, payoutAmount, beneficiary, netPayoutAmount);
+        // TODO callback IPolicyHolder
     }
 
-    // TODO create (I)TreasuryService that deals with all gif related token transfers
-    function _transferPayoutAmount(
+    function _calculatePayoutAmount(
         InstanceReader instanceReader,
         NftId policyNftId,
         IPolicy.PolicyInfo memory policyInfo,
@@ -341,6 +402,7 @@ contract ClaimService is
         internal
         returns (
             Amount netPayoutAmount,
+            Amount processingFeeAmount,
             address beneficiary
         )
     {
@@ -354,39 +416,22 @@ contract ClaimService is
             IComponents.ComponentInfo memory poolInfo = instanceReader.getComponentInfo(poolNftId);
 
             netPayoutAmount = payoutAmount;
-            beneficiary = _getBeneficiary(policyNftId, payoutInfo.claimId);
+
+            if (payoutInfo.beneficiary == address(0)) {
+                beneficiary = getRegistry().ownerOf(policyNftId);
+            } else { 
+                beneficiary = payoutInfo.beneficiary;
+            }
 
             IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
             if(FeeLib.gtz(productInfo.processingFee)) {
-                // TODO calculate net payout and processing fees
-                // TODO transfer processing fees to product wallet
-                // TODO inform product to update fee book keeping
+                // TODO calculate and set net payout and processing fees
             }
-
-            poolInfo.tokenHandler.transfer(
-                poolInfo.wallet,
-                beneficiary,
-                netPayoutAmount);
         }
     }
 
     // internal functions
 
-    function _getBeneficiary(
-        NftId policyNftId,
-        ClaimId claimId
-    )
-        internal
-        returns (address beneficiary)
-    {
-        // TODO check if owner is IPolicyHolder
-        // if so, obtain beneficiary from this contract
-
-        // default beneficiary is policy nft owner
-        beneficiary = getRegistry().ownerOf(policyNftId);
-    }
-
-
     function _verifyCallerWithPolicy(
         NftId policyNftId
     )

package/contracts/product/ClaimServiceManager.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {ClaimService} from "./ClaimService.sol";
 
 contract ClaimServiceManager is ProxyManager {

package/contracts/product/IApplicationService.sol

@@ -24,6 +24,7 @@ interface IApplicationService is IService {
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,

package/contracts/product/IClaimService.sol

@@ -23,14 +23,17 @@ interface IClaimService is
     event LogClaimServiceClaimSubmitted(NftId policyNftId, ClaimId claimId, Amount claimAmount);
     event LogClaimServiceClaimConfirmed(NftId policyNftId, ClaimId claimId, Amount confirmedAmount);
     event LogClaimServiceClaimDeclined(NftId policyNftId, ClaimId claimId);
+    event LogClaimServiceClaimRevoked(NftId policyNftId, ClaimId claimId);
     event LogClaimServiceClaimClosed(NftId policyNftId, ClaimId claimId);
 
     event LogClaimServicePayoutCreated(NftId policyNftId, PayoutId payoutId, Amount amount);
-    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary, Amount netAmount);
+    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary, Amount netAmount, Amount processingFeeAmount);
 
     error ErrorClaimServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
     error ErrorClaimServicePolicyNotOpen(NftId policyNftId);
     error ErrorClaimServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
+    error ErrorClaimServiceBeneficiaryIsZero(NftId policyNftId, ClaimId claimId);
+    error ErrorClaimsServicePayoutAmountIsZero(NftId policyNftId, PayoutId payoutId);
 
     error ErrorClaimServiceClaimWithOpenPayouts(NftId policyNftId, ClaimId claimId, uint8 openPayouts);
     error ErrorClaimServiceClaimWithMissingPayouts(NftId policyNftId, ClaimId claimId, Amount claimAmount, Amount paidAmount);
@@ -46,9 +49,6 @@ interface IClaimService is
     ) external returns (ClaimId claimId);
 
 
-    // TODO add claim revoke functionality
-
-
     /// @dev declines the specified claim
     /// function can only be called by product, policy needs to match with calling product
     function decline(
@@ -58,6 +58,14 @@ interface IClaimService is
     ) external;
 
 
+    /// @dev revokes the specified claim
+    /// function can only be called by product, policy needs to match with calling product
+    function revoke(
+        NftId policyNftId, 
+        ClaimId claimId
+    ) external;
+
+
     /// @dev confirms the specified claim and specifies the payout amount
     /// function can only be called by product, policy needs to match with calling product
     function confirm(
@@ -76,7 +84,8 @@ interface IClaimService is
     ) external;
 
 
-    /// @dev creates a new payout for the specified claim
+    /// @dev Creates a new payout for the specified claim.
+    /// The beneficiary is the holder of the policy NFT
     /// returns the id of the newly created payout, this id is unique for the specified policy
     /// function can only be called by product, policy needs to match with calling product
     function createPayout(
@@ -89,6 +98,20 @@ interface IClaimService is
         returns (PayoutId payoutId);
 
 
+    /// @dev Creates a new payout for the specified claim and beneficiary.
+    /// returns the id of the newly created payout, this id is unique for the specified policy
+    /// function can only be called by product, policy needs to match with calling product
+    function createPayoutForBeneficiary(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        address beneficiary,
+        bytes memory data
+    )
+        external
+        returns (PayoutId payoutId);
+
+
     /// @dev processes the specified payout
     /// this includes moving the payout token to the beneficiary (default: policy holder)
     /// function can only be called by product, policy needs to match with calling product

package/contracts/product/IPolicyService.sol

@@ -1,54 +1,48 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IRisk} from "../instance/module/IRisk.sol";
 import {IService} from "../shared/IService.sol";
 
 import {Amount} from "../type/Amount.sol";
-import {ClaimId} from "../type/ClaimId.sol";
 import {NftId} from "../type/NftId.sol";
-import {PayoutId} from "../type/PayoutId.sol";
-import {ReferralId} from "../type/Referral.sol";
-import {RiskId} from "../type/RiskId.sol";
-import {Seconds} from "../type/Seconds.sol";
 import {StateId} from "../type/StateId.sol";
 import {Timestamp} from "../type/Timestamp.sol";
-import {UFixed} from "../type/UFixed.sol";
-import {Fee} from "../type/Fee.sol";
 
 interface IPolicyService is IService {
 
     error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
     error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
-    error ErrorPolicyServicePolicyStateNotCollateralizedOrApplied(NftId applicationNftId);
+    error ErrorPolicyServicePolicyStateNotCollateralized(NftId applicationNftId);
+    error ErrorPolicyServicePolicyAlreadyActivated(NftId policyNftId);
 
-    error ErrorPolicyServicePremiumHigherThanExpected(Amount premiumExpectedAmount, Amount premiumToBePaidAmount);
     error ErrorPolicyServiceBalanceInsufficient(address policyOwner, uint256 premiumAmount, uint256 balance);
     error ErrorPolicyServiceAllowanceInsufficient(address policyOwner, address tokenHandler, uint256 premiumAmount, uint256 allowance);
 
-    error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
-    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId, Amount premiumPaidAmount);
-    error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
-    error ErrorIPolicyServicePolicyAlreadyClosed(NftId policyNftId);
-    error ErrorIPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
-    error ErrorPolicyServicePremiumNotFullyPaid(NftId policyNftId, Amount premiumAmount, Amount premiumPaidAmount);
-    error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
-    error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
+    error ErrorPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId);
+    error ErrorPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+    error ErrorPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
+    error ErrorPolicyServicePremiumNotPaid(NftId policyNftId, Amount premiumAmount);
+    error ErrorPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
+    error ErrorPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
+    error ErrorPolicyServicePolicyExpirationTooLate(NftId policyNftId, Timestamp upperLimit, Timestamp expiredAt);
+    error ErrorPolicyServicePolicyExpirationTooEarly(NftId policyNftId, Timestamp lowerLimit, Timestamp expiredAt);
 
     error ErrorPolicyServicePremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount recalculatedPremiumAmount);
     error ErrorPolicyServiceTransferredPremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount transferredPremiumAmount);
 
-    /// @dev collateralizes the policy represented by {policyNftId}
-    /// sets the policy state to collateralized
-    /// may set the policy state to activated and set the activation date
-    /// optionally collects premiums and activates the policy.
-    /// - premium payment is only attempted if requirePremiumPayment is set to true
-    /// - activation is only done if activateAt is a non-zero timestamp
-    /// an application can only be collateralized in applied state
-    /// only the related product may collateralize an application
-    function collateralize(
-        NftId policyNftId,
-        bool requirePremiumPayment,
+    event LogPolicyServicePolicyDeclined(NftId policyNftId);
+    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);
+
+    /// @dev creates the policy from {applicationNftId}. 
+    /// After successful completion of the function the policy can be referenced using the application NftId.
+    /// Locks the sum insured amount in the pool, but does not transfer tokens. Call collectPremium to transfer tokens. 
+    /// Sets the policy state to collateralized.
+    /// Optionally activates the policy if activateAt is a non-zero timestamp.
+    /// only the related product may create a policy from an application
+    function createPolicy(
+        NftId applicationNftId,
         Timestamp activateAt
     ) external;
 
@@ -57,18 +51,19 @@ interface IPolicyService is IService {
     /// only the related product may decline an application
     function decline(NftId policyNftId) external;
 
-    /// @dev collects the premium token for the specified policy
+    /// @dev collects the premium token for the specified policy (must be in COLLATERALIZED state)
     function collectPremium(NftId policyNftId, Timestamp activateAt) external;
 
     /// @dev activates the specified policy and sets the activation date in the policy metadata
     /// to activate a policy it needs to be in underwritten state
     function activate(NftId policyNftId, Timestamp activateAt) external;
 
-    /// @dev expires the specified policy and sets the expiry date in the policy metadata
+    /// @dev expires the specified policy and sets the expiry date in the policy metadata. If expiry date is set to 0, then the earliest possible expiry date (current blocktime) is set
     /// to expire a policy it must be in active state, policies may be expired even when the predefined expiry date is still in the future
     /// a policy can only be closed when it has been expired. in addition, it must not have any open claims
     /// this function can only be called by a product. the policy needs to match with the calling product
-    function expire(NftId policyNftId) external;
+    /// @return expiredAt the effective expiry date
+    function expire(NftId policyNftId, Timestamp expireAt) external returns (Timestamp expiredAt);
 
     /// @dev closes the specified policy and sets the closed data in the policy metadata
     /// a policy can only be closed when it has been expired. in addition, it must not have any open claims

package/contracts/product/IPricingService.sol

@@ -16,12 +16,12 @@ interface IPricingService is IService
     error ErrorPricingServiceTargetWalletAmountsMismatch();
     error ErrorIPricingServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
     error ErrorIPricingServiceFeeCalculationMismatch(
-                uint256 distributionFeeFixAmount,
-                uint256 distributionFeeVarAmount,
-                uint256 distributionOwnerFeeFixAmount,
-                uint256 distributionOwnerFeeVarAmount,
-                uint256 commissionAmount,
-                uint256 discountAmount
+                Amount distributionFeeFixAmount,
+                Amount distributionFeeVarAmount,
+                Amount distributionOwnerFeeFixAmount,
+                Amount distributionOwnerFeeVarAmount,
+                Amount commissionAmount,
+                Amount discountAmount
             );
 
     function calculatePremium(
@@ -35,5 +35,5 @@ interface IPricingService is IService
     )
         external
         view
-        returns (IPolicy.Premium memory premium);
+        returns (IPolicy.PremiumInfo memory premium);
 }

package/contracts/product/IProductComponent.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
-import {Fee} from "../type/Fee.sol";
 import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {NftId} from "../type/NftId.sol";
@@ -10,12 +9,9 @@ import {ReferralId} from "../type/Referral.sol";
 import {RiskId} from "../type/RiskId.sol";
 import {Seconds} from "../type/Seconds.sol";
 
-interface IProductComponent is IInstanceLinkedComponent {
-
-    function setFees(
-        Fee memory productFee,
-        Fee memory processingFee
-    ) external;
+interface IProductComponent is
+    IInstanceLinkedComponent
+{
 
     function calculatePremium(
         Amount sumInsuredAmount,
@@ -33,10 +29,11 @@ interface IProductComponent is IInstanceLinkedComponent {
         bytes memory applicationData
     ) external view returns (Amount netPremiumAmount);    
 
+    function getPoolNftId() external view returns (NftId poolNftId);
+    function getDistributionNftId() external view returns (NftId distributionNftId);
+
 
     /// @dev returns initial pool specific infos for this pool
     function getInitialProductInfo() external view returns (IComponents.ProductInfo memory info);
-
-    function getPoolNftId() external view returns (NftId poolNftId);
-    function getDistributionNftId() external view returns (NftId distributionNftId);
+    
 }

package/contracts/product/{IProductService.sol → IRiskService.sol}

@@ -12,7 +12,7 @@ import {Timestamp} from "../type/Timestamp.sol";
 import {UFixed} from "../type/UFixed.sol";
 import {Fee} from "../type/Fee.sol";
 
-interface IProductService is IService {
+interface IRiskService is IService {
 
     function createRisk(
         RiskId riskId,