@etherisc/gif-next 0.0.2-bdcb44f-543 → 0.0.2-be8b3db-650

package/contracts/instance/service/BundleService.sol

@@ -1,22 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {Pool} from "../../components/Pool.sol";
+import {IBundle} from "../../instance/module/IBundle.sol";
+import {IComponents} from "../module/IComponents.sol";
 import {IRegistry} from "../../registry/IRegistry.sol";
 import {IInstance} from "../../instance/IInstance.sol";
-import {IBundle} from "../../instance/module/IBundle.sol";
 import {TokenHandler} from "../../instance/module/ITreasury.sol";
 import {ISetup} from "../module/ISetup.sol";
 import {IPolicy} from "../module/IPolicy.sol";
 
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {INftOwnable} from "../../shared/INftOwnable.sol";
-
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {ObjectType, POOL, BUNDLE} from "../../types/ObjectType.sol";
 import {POOL_OWNER_ROLE, RoleId} from "../../types/RoleId.sol";
+import {Pool} from "../../components/Pool.sol";
+
 import {Fee, FeeLib} from "../../types/Fee.sol";
-import {KEEP_STATE, StateId} from "../../types/StateId.sol";
+import {StateId, ACTIVE, PAUSED, CLOSED, KEEP_STATE} from "../../types/StateId.sol";
 import {Seconds} from "../../types/Seconds.sol";
 import {TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {Version, VersionLib} from "../../types/Version.sol";
@@ -64,7 +65,7 @@ contract BundleService is
         return BUNDLE();
     }
 
-    function createBundle(
+    function create(
         address owner, 
         Fee memory fee, 
         uint256 stakingAmount, 
@@ -119,7 +120,7 @@ contract BundleService is
         // TODO add logging
     }
 
-    function setBundleFee(
+    function setFee(
         NftId bundleNftId,
         Fee memory fee
     )
@@ -139,30 +140,6 @@ contract BundleService is
         instance.updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
     }
 
-    function updateBundle(NftId instanceNftId, NftId bundleNftId, IBundle.BundleInfo memory bundleInfo, StateId state) 
-        external
-        onlyService
-    {
-        IRegistry.ObjectInfo memory instanceInfo = getRegistry().getObjectInfo(instanceNftId);
-        IInstance instance = IInstance(instanceInfo.objectAddress);
-        instance.updateBundle(bundleNftId, bundleInfo, state);
-    } 
-
-    function lockBundle(NftId bundleNftId) 
-        external
-    {
-        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
-        BundleManager bundleManager = instance.getBundleManager();
-        bundleManager.lock(bundleNftId);
-    }
-
-    function unlockBundle(NftId bundleNftId) 
-        external
-    {
-        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
-        BundleManager bundleManager = instance.getBundleManager();
-        bundleManager.unlock(bundleNftId);
-    }
 
     function lockCollateral(
         IInstance instance,
@@ -191,6 +168,64 @@ contract BundleService is
         linkPolicy(instance, policyNftId);
     }
 
+
+    function lock(NftId bundleNftId) 
+        external
+        virtual
+    {
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+
+        // udpate bundle state
+        instance.updateBundleState(bundleNftId, PAUSED());
+
+        // update set of active bundles
+        BundleManager bundleManager = instance.getBundleManager();
+        bundleManager.lock(bundleNftId);
+
+        emit LogBundleServiceBundleLocked(bundleNftId);
+    }
+
+
+    function unlock(NftId bundleNftId) 
+        external
+        virtual
+    {
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+
+        // udpate bundle state
+        instance.updateBundleState(bundleNftId, ACTIVE());
+
+        // update set of active bundles
+        BundleManager bundleManager = instance.getBundleManager();
+        bundleManager.unlock(bundleNftId);
+
+        emit LogBundleServiceBundleActivated(bundleNftId);
+    }
+
+
+    function close(NftId bundleNftId) 
+        external
+        virtual
+    {
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(POOL());
+
+        // udpate bundle state
+        instance.updateBundleState(bundleNftId, CLOSED());
+
+        // ensure no open policies attached to bundle
+        BundleManager bundleManager = instance.getBundleManager();
+        uint256 openPolicies = bundleManager.activePolicies(bundleNftId);
+        if(openPolicies > 0) {
+            revert ErrorBundleServiceBundleWithOpenPolicies(bundleNftId, openPolicies);
+        }
+
+        // update set of active bundles
+        bundleManager.lock(bundleNftId);
+
+        emit LogBundleServiceBundleClosed(bundleNftId);
+    }
+
+
     function increaseBalance(IInstance instance,
         NftId bundleNftId, 
         uint256 amount
@@ -235,7 +270,7 @@ contract BundleService is
 
         // ensure policy has not yet been activated
         if (policyInfo.activatedAt.gtz()) {
-            revert BundleManager.ErrorBundleManagerErrorPolicyAlreadyActivated(policyNftId);
+            revert BundleManager.ErrorBundleManagerPolicyAlreadyActivated(policyNftId);
         }
         
         BundleManager bundleManager = instance.getBundleManager();
@@ -278,18 +313,20 @@ contract BundleService is
     {
         // process token transfer(s)
         if(stakingAmount > 0) {
-            ISetup.PoolSetupInfo memory poolInfo = instanceReader.getPoolSetupInfo(poolNftId);
-            TokenHandler tokenHandler = poolInfo.tokenHandler;
+            IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
+            IComponents.PoolInfo memory poolInfo = abi.decode(
+                componentInfo.data, (IComponents.PoolInfo));
+
+            TokenHandler tokenHandler = componentInfo.tokenHandler;
             address bundleOwner = getRegistry().ownerOf(bundleNftId);
             Fee memory stakingFee = poolInfo.stakingFee;
 
             tokenHandler.transfer(
                 bundleOwner,
-                poolInfo.wallet,
+                componentInfo.wallet,
                 stakingAmount
             );
 
-
             if (! FeeLib.feeIsZero(stakingFee)) {
                 (uint256 stakingFeeAmount, uint256 netAmount) = FeeLib.calculateFee(stakingFee, stakingAmount);
                 // TODO: track staking fees in pool's state (issue #177)

package/contracts/instance/service/DistributionService.sol

@@ -42,6 +42,7 @@ contract DistributionService is
     using TimestampLib for Timestamp;
     using UFixedLib for UFixed;
     using FeeLib for Fee;
+    using ReferralLib for ReferralId;
 
     address internal _registryAddress;
     
@@ -255,20 +256,50 @@ contract DistributionService is
     }
 
     function processSale(
+        NftId distributionNftId,
         ReferralId referralId,
-        uint256 premiumAmount
+        IPolicy.Premium memory premium,
+        uint256 transferredDistributionFeeAmount
     )
         external
         virtual
     {
-        // TODO: fetch referral
-        // TODO: update referral usage numbers
-        // TODO: update bookkeeping
-        // TODO: calculate commission for distributor
-        // TODO: calculate fee for distribution owner
-        // TODO: updates sum of commission per distributor -> DistributorInfo
-        // TODO: updates sum of fee per distribution owner
-        revert("NOT_IMPLEMENTED_YET");
+        bool isReferral = ! referralId.eqz();
+        bool referralValid = referralIsValid(distributionNftId, referralId);
+
+        if (isReferral && ! referralValid) {
+            revert ErrorIDistributionServiceReferralInvalid(distributionNftId, referralId);
+        }
+
+        (, IInstance instance) = _getAndVerifyDistribution(distributionNftId);
+        InstanceReader reader = instance.getInstanceReader();
+        IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
+        IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
+        ISetup.DistributionSetupInfo memory setupInfo = reader.getDistributionSetupInfo(distributionNftId);
+        
+        uint256 distributionOwnerFee = premium.distributionOwnerFeeFixAmount + premium.distributionOwnerFeeVarAmount;
+        uint256 commissionAmount = premium.commissionAmount;
+
+        if (transferredDistributionFeeAmount != distributionOwnerFee + commissionAmount) {
+            revert ErrorIDistributionServiceInvalidFeeTransferred(transferredDistributionFeeAmount, distributionOwnerFee + commissionAmount);
+        }
+
+
+        if (distributionOwnerFee > 0) {
+            setupInfo.sumDistributionOwnerFees += distributionOwnerFee;
+            instance.updateDistributionSetup(distributionNftId, setupInfo, KEEP_STATE());
+        }
+
+        if (isReferral) {
+            referralInfo.usedReferrals += 1;
+            instance.updateReferral(referralId.toKey32(), referralInfo, KEEP_STATE());
+
+            if (commissionAmount > 0) {
+                distributorInfo.sumCommisions += commissionAmount;
+                distributorInfo.numPoliciesSold += 1;
+                instance.updateDistributor(referralInfo.distributorNftId, distributorInfo, KEEP_STATE());
+            }
+        }
     }
 
     function calculateFeeAmount(
@@ -302,20 +333,45 @@ contract DistributionService is
 
         // if the referral is valid, the the commission and discount are calculated based in the full premium
         // the remaing amount goes to the distribution owner
-        IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
-        IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
-        IDistribution.DistributorTypeInfo memory distributorTypeInfo = reader.getDistributorTypeInfo(distributorInfo.distributorType);
-
-        uint256 commissionAmount = UFixedLib.toUFixed(premium.netPremiumAmount).mul(distributorTypeInfo.commissionPercentage).toInt();
-        premium.commissionAmount = commissionAmount;
-        premium.discountAmount = UFixedLib.toUFixed(premium.fullPremiumAmount).mul(referralInfo.discountPercentage).toInt();
-        premium.distributionOwnerFeeFixAmount = minDistributionOwnerFee.fixedFee;
-        premium.distributionOwnerFeeVarAmount = distributionFeeVarAmount - commissionAmount - premium.discountAmount;
-        premium.premiumAmount = premium.fullPremiumAmount - premium.discountAmount;
+        {
+            IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
+            IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
+            IDistribution.DistributorTypeInfo memory distributorTypeInfo = reader.getDistributorTypeInfo(distributorInfo.distributorType);
+
+            uint256 commissionAmount = UFixedLib.toUFixed(premium.netPremiumAmount).mul(distributorTypeInfo.commissionPercentage).toInt();
+            premium.commissionAmount = commissionAmount;
+            premium.discountAmount = UFixedLib.toUFixed(premium.fullPremiumAmount).mul(referralInfo.discountPercentage).toInt();
+            premium.distributionOwnerFeeFixAmount = minDistributionOwnerFee.fixedFee;
+            premium.distributionOwnerFeeVarAmount = distributionFeeVarAmount - commissionAmount - premium.discountAmount;
+            premium.premiumAmount = premium.fullPremiumAmount - premium.discountAmount;
+        }
+
+        // sanity check to validate the fee calculation
+        if (premium.distributionOwnerFeeFixAmount < minDistributionOwnerFee.fixedFee) {
+            revert ErrorIDistributionServiceFeeCalculationMismatch(
+                premium.distributionFeeFixAmount,
+                premium.distributionFeeVarAmount,
+                premium.distributionOwnerFeeFixAmount,
+                premium.distributionOwnerFeeVarAmount,
+                premium.commissionAmount,
+                premium.discountAmount
+            );
+        }
+        if ((premium.distributionFeeVarAmount) != (premium.discountAmount + premium.distributionOwnerFeeVarAmount + premium.commissionAmount)) {
+            revert ErrorIDistributionServiceFeeCalculationMismatch(
+                premium.distributionFeeFixAmount,
+                premium.distributionFeeVarAmount,
+                premium.distributionOwnerFeeFixAmount,
+                premium.distributionOwnerFeeVarAmount,
+                premium.commissionAmount,
+                premium.discountAmount
+            );
+        }
         
         return premium; 
     }
 
+    // TODO: zero should return false
     function referralIsValid(NftId distributionNftId, ReferralId referralId) public view returns (bool isValid) {
         (address distributionAddress, IInstance instance) = _getAndVerifyDistribution(distributionNftId);
         IDistribution.ReferralInfo memory info = instance.getInstanceReader().getReferralInfo(referralId);

package/contracts/instance/service/IBundleService.sol

@@ -10,9 +10,16 @@ import {Seconds} from "../../types/Seconds.sol";
 import {StateId} from "../../types/StateId.sol";
 
 interface IBundleService is IService {
-    error ErrorIBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
 
-    function createBundle(
+    event LogBundleServiceBundleActivated(NftId bundleNftId);
+    event LogBundleServiceBundleLocked(NftId bundleNftId);
+    event LogBundleServiceBundleClosed(NftId bundleNftId);
+
+    error ErrorBundleServiceInsufficientAllowance(address bundleOwner, address tokenHandlerAddress, uint256 amount);
+    error ErrorBundleServiceBundleNotOpen(NftId bundleNftId, StateId state);
+    error ErrorBundleServiceBundleWithOpenPolicies(NftId bundleNftId, uint256 openPoliciesCount);
+
+    function create(
         address owner,
         Fee memory fee, 
         uint256 amount,
@@ -20,12 +27,12 @@ interface IBundleService is IService {
         bytes calldata filter
     ) external returns(NftId bundleNftId);
 
-    function setBundleFee(
+
+    function setFee(
         NftId bundleNftId,
         Fee memory fee
     ) external;
 
-    function updateBundle(NftId instanceNftId, NftId bundleNftId, IBundle.BundleInfo memory bundleInfo, StateId state) external;
 
     function lockCollateral(
         IInstance instanceNftId, 
@@ -43,13 +50,13 @@ interface IBundleService is IService {
 
     function closePolicy(IInstance instance, NftId policyNftId, NftId bundleNftId, uint256 collateralAmount) external;
 
-    // function fundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    // function stake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 
-    // function defundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
+    // function unstake(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 
-    function lockBundle(NftId bundleNftId) external;
+    function lock(NftId bundleNftId) external;
 
-    function unlockBundle(NftId bundleNftId) external;
+    function unlock(NftId bundleNftId) external;
 
-    // function closeBundle(NftId bundleNftId) external;
+    function close(NftId bundleNftId) external;
 }

package/contracts/instance/service/IDistributionService.sol

@@ -24,6 +24,16 @@ interface IDistributionService is IService {
     error ErrorIDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
     error ErrorIDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
     error ErrorIDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
+    error ErrorIDistributionServiceFeeCalculationMismatch(
+                uint256 distributionFeeFixAmount,
+                uint256 distributionFeeVarAmount,
+                uint256 distributionOwnerFeeFixAmount,
+                uint256 distributionOwnerFeeVarAmount,
+                uint256 commissionAmount,
+                uint256 discountAmount
+            );
+    error ErrorIDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
+    error ErrorIDistributionServiceInvalidFeeTransferred(uint256 transferredDistributionFeeAmount, uint256 expectedDistributionFeeAmount);
 
     function setFees(
         Fee memory minDistributionOwnerFee,
@@ -69,8 +79,10 @@ interface IDistributionService is IService {
 
     /// @dev callback from product service when selling a policy for a specific referralId
     function processSale(
+        NftId distributionNftId,
         ReferralId referralId,
-        uint256 premiumAmount
+        IPolicy.Premium memory premium,
+        uint256 transferredDistributionFeeAmount
     ) external;
 
     function calculateFeeAmount(

package/contracts/instance/service/IPolicyService.sol

@@ -24,6 +24,8 @@ interface IPolicyService is IService {
     error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
     error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
 
+    error ErrorIPolicyServicePremiumMismatch(NftId policyNftId, uint256 premiumAmount, uint256 recalculatedPremiumAmount);
+
     /// @dev declines an application represented by {policyNftId}
     /// an application can only be declined in applied state
     /// only the related product may decline an application

package/contracts/instance/service/IPoolService.sol

@@ -1,17 +1,32 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {NftId} from "../../types/NftId.sol";
 import {Fee} from "../../types/Fee.sol";
-import {StateId} from "../../types/StateId.sol";
+import {NftId} from "../../types/NftId.sol";
 import {IService} from "../../shared/IService.sol";
 import {IBundle} from "../module/IBundle.sol";
 import {IInstance} from "../../instance/IInstance.sol";
+import {RoleId} from "../../types/RoleId.sol";
+import {StateId} from "../../types/StateId.sol";
 
 interface IPoolService is IService {
 
+    event LogPoolServiceMaxCapitalAmountUpdated(NftId poolNftId, uint256 previousMaxCapitalAmount, uint256 currentMaxCapitalAmount);
+    event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
+
+    error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
+
+    /// @dev registers a new pool with the registry service
     function register(address poolAddress) external returns(NftId);
 
+    /// @dev defines the required role for bundle owners for the calling pool
+    /// default implementation returns PUBLIC ROLE
+    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
+
+    /// @dev sets the max capital amount for the calling pool
+    function setMaxCapitalAmount(uint256 maxCapitalAmount) external;
+
+    /// @dev set pool sepecific fees
     function setFees(
         Fee memory poolFee,
         Fee memory stakingFee,

package/contracts/instance/service/PolicyService.sol

@@ -2,45 +2,34 @@
 pragma solidity ^0.8.19;
 
 import {IRegistry} from "../../registry/IRegistry.sol";
-import {IProductComponent} from "../../components/IProductComponent.sol";
 import {Product} from "../../components/Product.sol";
-import {IPoolComponent} from "../../components/IPoolComponent.sol";
+import {IComponents} from "../module/IComponents.sol";
 import {IDistributionComponent} from "../../components/IDistributionComponent.sol";
 import {IInstance} from "../IInstance.sol";
 import {IPolicy} from "../module/IPolicy.sol";
+import {IPoolComponent} from "../../components/IPoolComponent.sol";
 import {IRisk} from "../module/IRisk.sol";
 import {IBundle} from "../module/IBundle.sol";
-import {IProductService} from "./IProductService.sol";
-import {ITreasury} from "../module/ITreasury.sol";
 import {ISetup} from "../module/ISetup.sol";
 
 import {TokenHandler} from "../../shared/TokenHandler.sol";
 
-import {IVersionable} from "../../shared/IVersionable.sol";
-import {Versionable} from "../../shared/Versionable.sol";
-
-import {Seconds} from "../../types/Seconds.sol";
 import {Timestamp, TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {UFixed, UFixedLib} from "../../types/UFixed.sol";
-import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
-import {ObjectType, APPLICATION, INSTANCE, PRODUCT, POOL, POLICY, BUNDLE} from "../../types/ObjectType.sol";
+import {ObjectType, APPLICATION, DISTRIBUTION, PRODUCT, POOL, POLICY, BUNDLE} from "../../types/ObjectType.sol";
 import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE, CLOSED} from "../../types/StateId.sol";
-import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
-import {Fee, FeeLib} from "../../types/Fee.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
+import {NftId, NftIdLib} from "../../types/NftId.sol";
 import {StateId} from "../../types/StateId.sol";
-import {Version, VersionLib} from "../../types/Version.sol";
-//import {RoleId, PRODUCT_OWNER_ROLE} from "../../types/RoleId.sol";
 
-import {IService} from "../../shared/IService.sol";
-import {Service} from "../../shared/Service.sol";
 import {ComponentService} from "../base/ComponentService.sol";
 import {IApplicationService} from "./IApplicationService.sol";
-import {IPolicyService} from "./IPolicyService.sol";
+import {IBundleService} from "./IBundleService.sol";
+import {IDistributionService} from "./IDistributionService.sol";
 import {InstanceReader} from "../InstanceReader.sol";
+import {IPolicyService} from "./IPolicyService.sol";
 import {IPoolService} from "./IPoolService.sol";
-import {IBundleService} from "./IBundleService.sol";
+import {IService} from "../../shared/IService.sol";
+import {Service} from "../../shared/Service.sol";
 
 
 contract PolicyService is
@@ -53,6 +42,7 @@ contract PolicyService is
     IPoolService internal _poolService;
     IBundleService internal _bundleService;
     IApplicationService internal _applicationService;
+    IDistributionService internal _distributionService;
 
     event LogProductServiceSender(address sender);
 
@@ -73,6 +63,7 @@ contract PolicyService is
         _poolService = IPoolService(getRegistry().getServiceAddress(POOL(), getMajorVersion()));
         _bundleService = IBundleService(getRegistry().getServiceAddress(BUNDLE(), getMajorVersion()));
         _applicationService = IApplicationService(getRegistry().getServiceAddress(APPLICATION(), getMajorVersion()));
+        _distributionService = IDistributionService(getRegistry().getServiceAddress(DISTRIBUTION(), getMajorVersion()));
 
         registerInterface(type(IPolicyService).interfaceId);
     }
@@ -111,7 +102,9 @@ contract PolicyService is
         require(bundleInfo.poolNftId == poolNftId, "POLICY_BUNDLE_MISMATCH");
 
         // calculate required collateral
-        ISetup.PoolSetupInfo memory poolInfo = instanceReader.getPoolSetupInfo(poolNftId);
+        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
+        IComponents.PoolInfo memory poolInfo = abi.decode(
+            componentInfo.data, (IComponents.PoolInfo));
 
         // obtain remaining return values
         // TODO required collateral amount should be calculated by pool service, not policy service
@@ -184,7 +177,6 @@ contract PolicyService is
         if(requirePremiumPayment) {
             netPremiumAmount = _processPremiumByTreasury(
                 instance, 
-                productNftId,
                 applicationNftId, 
                 policyInfo.premiumAmount);
 
@@ -212,7 +204,12 @@ contract PolicyService is
         instance.updatePolicy(applicationNftId, policyInfo, newPolicyState);
 
         // also verify/confirm application by pool if necessary
-        if(instanceReader.getPoolSetupInfo(poolNftId).isVerifyingApplications) {
+        if(abi.decode(
+            instanceReader.getComponentInfo(poolNftId).data, 
+            (IComponents.PoolInfo)
+            ).isVerifyingApplications
+        )
+        {
             IPoolComponent pool = IPoolComponent(
                 getRegistry().getObjectInfo(poolNftId).objectAddress);
 
@@ -248,7 +245,6 @@ contract PolicyService is
 
         uint256 netPremiumAmount = _processPremiumByTreasury(
                 instance, 
-                productInfo.nftId,
                 policyNftId, 
                 unpaidPremiumAmount);
 
@@ -352,7 +348,6 @@ contract PolicyService is
 
     function _processPremiumByTreasury(
         IInstance instance,
-        NftId productNftId,
         NftId policyNftId,
         uint256 premiumAmount
     )
@@ -361,12 +356,12 @@ contract PolicyService is
     {
         // process token transfer(s)
         if(premiumAmount > 0) {
+            NftId productNftId = getRegistry().getObjectInfo(policyNftId).parentNftId;
             ISetup.ProductSetupInfo memory productSetupInfo = instance.getInstanceReader().getProductSetupInfo(productNftId);
             IPolicy.PolicyInfo memory policyInfo = instance.getInstanceReader().getPolicyInfo(policyNftId);
             TokenHandler tokenHandler = productSetupInfo.tokenHandler;
             address policyOwner = getRegistry().ownerOf(policyNftId);
-            ISetup.PoolSetupInfo memory poolSetupInfo = instance.getInstanceReader().getPoolSetupInfo(productSetupInfo.poolNftId);
-            address poolWallet = poolSetupInfo.wallet;
+            address poolWallet = instance.getInstanceReader().getComponentInfo(productSetupInfo.poolNftId).wallet;
             IPolicy.Premium memory premium = _applicationService.calculatePremium(
                 productNftId,
                 policyInfo.riskId,
@@ -377,24 +372,30 @@ contract PolicyService is
                 policyInfo.referralId
                 );
 
-            // if (FeeLib.feeIsZero(premium.productFeeAmount)) {
-            //     tokenHandler.transfer(
-            //         policyOwner,
-            //         poolWallet,
-            //         premiumAmount
-            //     );
-            // } else {
-                address productWallet = productSetupInfo.wallet;
-                if (tokenHandler.getToken().allowance(policyOwner, address(tokenHandler)) < premium.premiumAmount) {
-                    revert ErrorIPolicyServiceInsufficientAllowance(policyOwner, address(tokenHandler), premium.premiumAmount);
-                }
-                tokenHandler.transfer(policyOwner, productWallet, premium.productFeeFixAmount + premium.productFeeVarAmount);
-                tokenHandler.transfer(policyOwner, poolWallet, premium.netPremiumAmount);
-                netPremiumAmount = premium.netPremiumAmount;
-                // TODO: also move distribution tokens to distribution wallet and call `Distribution.processSale` to update distribution balances
-            // }
-            // TODO: move pool/bundle related tokens too
-
+            if (premium.premiumAmount != premiumAmount) {
+                revert ErrorIPolicyServicePremiumMismatch(policyNftId, premiumAmount, premium.premiumAmount);
+            }
+
+            // move product fee to product wallet
+            address productWallet = productSetupInfo.wallet;
+            if (tokenHandler.getToken().allowance(policyOwner, address(tokenHandler)) < premium.premiumAmount) {
+                revert ErrorIPolicyServiceInsufficientAllowance(policyOwner, address(tokenHandler), premium.premiumAmount);
+            }
+            tokenHandler.transfer(policyOwner, productWallet, premium.productFeeFixAmount + premium.productFeeVarAmount);
+
+            // move distribution fee to distribution wallet
+            ISetup.DistributionSetupInfo memory distributionSetupInfo = instance.getInstanceReader().getDistributionSetupInfo(productSetupInfo.distributionNftId);
+            address distributionWallet = distributionSetupInfo.wallet;
+            uint256 distributionFeeAmountToTransfer = premium.distributionFeeFixAmount + premium.distributionFeeVarAmount - premium.discountAmount;
+            tokenHandler.transfer(policyOwner, distributionWallet, distributionFeeAmountToTransfer);
+            _distributionService.processSale(productSetupInfo.distributionNftId, policyInfo.referralId, premium, distributionFeeAmountToTransfer);
+            
+            // move netpremium to pool wallet
+            tokenHandler.transfer(policyOwner, poolWallet, premium.netPremiumAmount);
+            
+            // TODO: move pool related tokens too
+            // TODO: move bundle related tokens too
+            netPremiumAmount = premium.netPremiumAmount;
         }
 
         // TODO: add logging