@etherisc/gif-next 0.0.2-e8ea17d-715 → 0.0.2-e8ea5fe-337

package/contracts/product/PricingService.sol

@@ -71,7 +71,7 @@ contract PricingService is
         view
         virtual override
         returns (
-            IPolicy.Premium memory premium
+            IPolicy.PremiumInfo memory premium
         )
     {
         InstanceReader reader;
@@ -84,6 +84,7 @@ contract PricingService is
                 IInstance instance
             ) = _getAndVerifyComponentInfo(productNftId, PRODUCT(), false);
 
+            // get instance reader from local instance variable
             reader = instance.getInstanceReader();
 
             // calculate net premium
@@ -104,19 +105,21 @@ contract PricingService is
                 revert ErrorIPricingServiceBundlePoolMismatch(bundleNftId, bundleInfo.poolNftId, productInfo.poolNftId);
             }
 
-            // calculate premium, order is important
+            // calculate fixed fees for product, pool, bundle
             premium = _getFixedFeeAmounts(
                 netPremiumAmount,
                 productInfo,
                 bundleInfo
             );
 
+            // calculate variable fees for product, pool, bundle
             premium = _calculateVariableFeeAmounts(
                 premium,
                 productInfo,
                 bundleInfo
             );
 
+            // calculate distribution fee and (if applicable) commission
             premium = _calculateDistributionOwnerFeeAmount(
                 premium,
                 productInfo,
@@ -124,18 +127,18 @@ contract PricingService is
                 reader
             );
 
+            // calculate resulting amounts for product, pool, and distribution wallets
             premium = _calculateTargetWalletAmounts(premium);
 
             // sanity check to validate the fee calculation
-            if(AmountLib.toAmount(premium.premiumAmount) != 
-                premium.productFeeAmount 
+            if(premium.premiumAmount != premium.productFeeAmount 
                 + premium.distributionFeeAndCommissionAmount 
                 + premium.poolPremiumAndFeeAmount)
             {
                 revert ErrorPricingServiceTargetWalletAmountsMismatch();
             }
 
-            if (premium.distributionOwnerFeeFixAmount < productInfo.minDistributionOwnerFee.fixedFee) {
+            if (premium.distributionOwnerFeeFixAmount.toInt() < productInfo.minDistributionOwnerFee.fixedFee) {
                 revert ErrorIPricingServiceFeeCalculationMismatch( 
                     premium.distributionFeeFixAmount,
                     premium.distributionFeeVarAmount,
@@ -168,64 +171,64 @@ contract PricingService is
         internal
         pure
         returns (
-            IPolicy.Premium memory premium
+            IPolicy.PremiumInfo memory premium
         )
     {
         // initial premium amount is the net premium
-        premium.netPremiumAmount = netPremiumAmount.toInt();
-        premium.fullPremiumAmount = netPremiumAmount.toInt();
+        premium.netPremiumAmount = netPremiumAmount;
+        premium.fullPremiumAmount = netPremiumAmount;
 
-        uint256 t = productInfo.productFee.fixedFee;
+        Amount t = AmountLib.toAmount(productInfo.productFee.fixedFee);
         premium.productFeeFixAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
 
-        t = productInfo.poolFee.fixedFee;
+        t = AmountLib.toAmount(productInfo.poolFee.fixedFee);
         premium.poolFeeFixAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
 
-        t = bundleInfo.fee.fixedFee;
+        t = AmountLib.toAmount(bundleInfo.fee.fixedFee);
         premium.bundleFeeFixAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
 
-        t = productInfo.distributionFee.fixedFee;
+        t = AmountLib.toAmount(productInfo.distributionFee.fixedFee);
         premium.distributionFeeFixAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
     }
 
     function _calculateVariableFeeAmounts(
-        IPolicy.Premium memory premium,
+        IPolicy.PremiumInfo memory premium,
         IComponents.ProductInfo memory productInfo,
         IBundle.BundleInfo memory bundleInfo
     )
         internal
         pure
         returns (
-            IPolicy.Premium memory intermadiatePremium
+            IPolicy.PremiumInfo memory intermadiatePremium
         )
     {
-        UFixed netPremiumAmount = UFixedLib.toUFixed(premium.netPremiumAmount);
+        Amount netPremiumAmount = premium.netPremiumAmount;
 
-        uint256 t = (netPremiumAmount * productInfo.productFee.fractionalFee).toInt();
+        Amount t = netPremiumAmount.multiplyWith(productInfo.productFee.fractionalFee);
         premium.productFeeVarAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
 
-        t = (netPremiumAmount * productInfo.poolFee.fractionalFee).toInt();
+        t = netPremiumAmount.multiplyWith(productInfo.poolFee.fractionalFee);
         premium.poolFeeVarAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
 
-        t = (netPremiumAmount * bundleInfo.fee.fractionalFee).toInt();
+        t = netPremiumAmount.multiplyWith(bundleInfo.fee.fractionalFee);
         premium.bundleFeeVarAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
 
-        t = (netPremiumAmount * productInfo.distributionFee.fractionalFee).toInt();
+        t = netPremiumAmount.multiplyWith(productInfo.distributionFee.fractionalFee);
         premium.distributionFeeVarAmount = t;
-        premium.fullPremiumAmount += t;
+        premium.fullPremiumAmount = premium.fullPremiumAmount + t;
 
         return premium;
     }
 
     function _calculateDistributionOwnerFeeAmount(
-        IPolicy.Premium memory premium,
+        IPolicy.PremiumInfo memory premium,
         IComponents.ProductInfo memory productInfo,
         // ISetup.DistributionSetupInfo memory distInfo,
         ReferralId referralId,
@@ -233,7 +236,7 @@ contract PricingService is
     )
         internal
         view 
-        returns (IPolicy.Premium memory finalPremium)
+        returns (IPolicy.PremiumInfo memory finalPremium)
     {
 
         // if the referral is not valid, then the distribution owner gets everything
@@ -253,10 +256,10 @@ contract PricingService is
             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();
+            Amount commissionAmount = premium.netPremiumAmount.multiplyWith(distributorTypeInfo.commissionPercentage);
             premium.commissionAmount = commissionAmount;
-            premium.discountAmount = UFixedLib.toUFixed(premium.fullPremiumAmount).mul(referralInfo.discountPercentage).toInt();
-            premium.distributionOwnerFeeFixAmount = minDistributionOwnerFee.fixedFee;
+            premium.discountAmount = premium.fullPremiumAmount.multiplyWith(referralInfo.discountPercentage);
+            premium.distributionOwnerFeeFixAmount = AmountLib.toAmount(minDistributionOwnerFee.fixedFee);
             premium.distributionOwnerFeeVarAmount = premium.distributionFeeVarAmount - commissionAmount - premium.discountAmount;
             premium.premiumAmount = premium.fullPremiumAmount - premium.discountAmount;
         }
@@ -266,29 +269,27 @@ contract PricingService is
 
 
     function _calculateTargetWalletAmounts(
-        IPolicy.Premium memory premium
+        IPolicy.PremiumInfo memory premium
     )
         internal
         virtual
         view
         returns (
-            IPolicy.Premium memory premiumWithTargetWalletAmounts
+            IPolicy.PremiumInfo memory premiumWithTargetWalletAmounts
         )
     {
         // fees for product owner
-        premium.productFeeAmount = AmountLib.toAmount(
-            premium.productFeeFixAmount + premium.productFeeVarAmount);
+        premium.productFeeAmount = premium.productFeeFixAmount + premium.productFeeVarAmount;
 
         // fees for distribution owner + distributor commission
-        premium.distributionFeeAndCommissionAmount = AmountLib.toAmount(
+        premium.distributionFeeAndCommissionAmount = 
             premium.distributionFeeFixAmount + premium.distributionOwnerFeeVarAmount 
-            + premium.commissionAmount);
+            + premium.commissionAmount;
 
         // net premium + fees for pool owner + bundle owner
-        premium.poolPremiumAndFeeAmount = AmountLib.toAmount(
-            premium.netPremiumAmount 
+        premium.poolPremiumAndFeeAmount = premium.netPremiumAmount 
             + premium.poolFeeFixAmount + premium.poolFeeVarAmount 
-            + premium.bundleFeeFixAmount + premium.bundleFeeVarAmount);
+            + premium.bundleFeeFixAmount + premium.bundleFeeVarAmount;
 
         premiumWithTargetWalletAmounts = premium;
     }

package/contracts/product/PricingServiceManager.sol

@@ -1,12 +1,9 @@
 // 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 {PricingService} from "./PricingService.sol";
-import {Registry} from "../registry/Registry.sol";
-import {RegistryService} from "../registry/RegistryService.sol";
-import {REGISTRY} from "../type/ObjectType.sol";
 
 contract PricingServiceManager is ProxyManager {
 

package/contracts/product/Product.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, AmountLib} from "../type/Amount.sol";
 import {ClaimId} from "../type/ClaimId.sol";
 import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
@@ -12,11 +10,11 @@ import {IApplicationService} from "./IApplicationService.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {IPolicyService} from "./IPolicyService.sol";
-import {IProductService} from "./IProductService.sol";
+import {IRiskService} from "./IRiskService.sol";
 import {IClaimService} from "./IClaimService.sol";
 import {IPricingService} from "./IPricingService.sol";
 import {IProductComponent} from "./IProductComponent.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
+import {NftId} from "../type/NftId.sol";
 import {PayoutId} from "../type/PayoutId.sol";
 import {COMPONENT, PRODUCT, APPLICATION, POLICY, CLAIM, PRICE } from "../type/ObjectType.sol";
 import {ReferralId} from "../type/Referral.sol";
@@ -25,9 +23,6 @@ import {Seconds} from "../type/Seconds.sol";
 import {StateId} from "../type/StateId.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 
-import {TokenHandler} from "../shared/TokenHandler.sol";
-
-import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {Pool} from "../pool/Pool.sol";
@@ -41,7 +36,7 @@ abstract contract Product is
     bytes32 public constant PRODUCT_STORAGE_LOCATION_V1 = 0x0bb7aafdb8e380f81267337bc5b5dfdf76e6d3a380ecadb51ec665246d9d6800;
 
     struct ProductStorage {
-        IProductService _productService;
+        IRiskService _riskService;
         IApplicationService _applicationService;
         IPolicyService _policyService;
         IClaimService _claimService;
@@ -62,12 +57,12 @@ abstract contract Product is
         NftId bundleNftId,
         ReferralId referralId
     )
-        external 
+        public 
         view 
         override 
         returns (Amount premiumAmount)
     {
-        IPolicy.Premium memory premium = _getProductStorage()._pricingService.calculatePremium(
+        IPolicy.PremiumInfo memory premium = _getProductStorage()._pricingService.calculatePremium(
             getNftId(),
             riskId,
             sumInsuredAmount,
@@ -77,14 +72,14 @@ abstract contract Product is
             referralId
         );
 
-        return AmountLib.toAmount(premium.premiumAmount);
+        return premium.premiumAmount;
     }
 
     function calculateNetPremium(
         Amount sumInsuredAmount,
-        RiskId riskId,
-        Seconds lifetime,
-        bytes memory applicationData
+        RiskId,
+        Seconds,
+        bytes memory
     )
         external
         view
@@ -102,6 +97,7 @@ abstract contract Product is
         onlyOwner()
     {
         _getProductStorage()._componentService.registerProduct();
+        _approveTokenHandler(type(uint256).max);
     }
 
 
@@ -127,14 +123,13 @@ abstract contract Product is
     }
 
     function getPoolNftId() external view override returns (NftId poolNftId) {
-        return getRegistry().getNftId(address(_getProductStorage()._pool));
+        return getRegistry().getNftIdForAddress(address(_getProductStorage()._pool));
     }
 
     function getDistributionNftId() external view override returns (NftId distributionNftId) {
-        return getRegistry().getNftId(address(_getProductStorage()._distribution));
+        return getRegistry().getNftIdForAddress(address(_getProductStorage()._distribution));
     }
 
-
     function _initializeProduct(
         address registry,
         NftId instanceNftId,
@@ -143,8 +138,9 @@ abstract contract Product is
         string memory name,
         address token,
         bool isInterceptor,
-        address pool,
-        address distribution,
+        address pool, // switch to pool nft id (#527)
+        address distribution, // switch to distribution nft id  (#527)
+        // add NftId [] oracleNftIds (#527)
         bytes memory registryData, // writeonly data that will saved in the object info record of the registry
         bytes memory componentData // writeonly data that will saved in the object info record of the registry
     )
@@ -166,8 +162,8 @@ abstract contract Product is
 
         ProductStorage storage $ = _getProductStorage();
         // TODO add validation
-        // TODO refactor to go via registry ?
-        $._productService = IProductService(_getServiceAddress(PRODUCT())); 
+        // TODO refactor to go via registry for all components linked to this product (#527)
+        $._riskService = IRiskService(_getServiceAddress(PRODUCT())); 
         $._applicationService = IApplicationService(_getServiceAddress(APPLICATION())); 
         $._policyService = IPolicyService(_getServiceAddress(POLICY())); 
         $._claimService = IClaimService(_getServiceAddress(CLAIM())); 
@@ -175,8 +171,8 @@ abstract contract Product is
         $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
         $._pool = Pool(pool);
         $._distribution = Distribution(distribution);
-        $._poolNftId = getRegistry().getNftId(pool);
-        $._distributionNftId = getRegistry().getNftId(distribution);
+        $._poolNftId = getRegistry().getNftIdForAddress(pool);
+        $._distributionNftId = getRegistry().getNftIdForAddress(distribution);
 
         registerInterface(type(IProductComponent).interfaceId);  
     }
@@ -197,7 +193,7 @@ abstract contract Product is
         RiskId id,
         bytes memory data
     ) internal {
-        _getProductService().createRisk(
+        _getRiskService().createRisk(
             id,
             data
         );
@@ -207,7 +203,7 @@ abstract contract Product is
         RiskId id,
         bytes memory data
     ) internal {
-        _getProductService().updateRisk(
+        _getRiskService().updateRisk(
             id,
             data
         );
@@ -217,7 +213,7 @@ abstract contract Product is
         RiskId id,
         StateId state
     ) internal {
-        _getProductService().updateRiskState(
+        _getRiskService().updateRiskState(
             id,
             state
         );
@@ -233,6 +229,7 @@ abstract contract Product is
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
@@ -245,6 +242,7 @@ abstract contract Product is
             applicationOwner,
             riskId,
             sumInsuredAmount,
+            premiumAmount,
             lifetime,
             bundleNftId,
             referralId,
@@ -252,19 +250,36 @@ abstract contract Product is
         );
     }
 
-    function _collateralize(
-        NftId policyNftId,
-        bool requirePremiumPayment,
+    function _createPolicy(
+        NftId applicationNftId,
         Timestamp activateAt
     )
         internal
     {
-        _getProductStorage()._policyService.collateralize(
-            policyNftId, 
-            requirePremiumPayment, 
+        _getProductStorage()._policyService.createPolicy(
+            applicationNftId, 
             activateAt);
     }
 
+    function _decline(
+        NftId policyNftId
+    )
+        internal
+    {
+        _getProductStorage()._policyService.decline(
+            policyNftId);
+    }
+
+    function _expire(
+        NftId policyNftId,
+        Timestamp expireAt
+    )
+        internal
+        returns (Timestamp expiredAt)
+    {
+        expiredAt = _getProductStorage()._policyService.expire(policyNftId, expireAt);
+    }
+
     function _collectPremium(
         NftId policyNftId,
         Timestamp activateAt
@@ -365,6 +380,24 @@ abstract contract Product is
             data);
     }
 
+    function _createPayoutForBeneficiary(
+        NftId policyNftId,
+        ClaimId claimId,
+        Amount amount,
+        address beneficiary,
+        bytes memory data
+    )
+        internal
+        returns (PayoutId)
+    {
+        return _getProductStorage()._claimService.createPayoutForBeneficiary(
+            policyNftId, 
+            claimId, 
+            amount, 
+            beneficiary,
+            data);
+    }
+
     function _processPayout(
         NftId policyNftId,
         PayoutId payoutId
@@ -386,7 +419,7 @@ abstract contract Product is
         }
     }
 
-    function _getProductService() internal view returns (IProductService) {
-        return _getProductStorage()._productService;
+    function _getRiskService() internal view returns (IRiskService) {
+        return _getProductStorage()._riskService;
     }
 }

package/contracts/product/{ProductService.sol → RiskService.sol}

@@ -1,56 +1,29 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IRegistry} from "../registry/IRegistry.sol";
-import {IProductComponent} from "./IProductComponent.sol";
-import {Product} from "./Product.sol";
-import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.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 {IInstanceService} from "../instance/IInstanceService.sol";
+import {IPoolService} from "../pool/PoolService.sol";
+import {IRiskService} from "./IRiskService.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
 import {IRisk} from "../instance/module/IRisk.sol";
-import {IBundle} from "../instance/module/IBundle.sol";
-import {IProductService} from "./IProductService.sol";
-import {IComponents} from "../instance/module/IComponents.sol";
 
-import {TokenHandler} from "../shared/TokenHandler.sol";
-
-import {IVersionable} from "../shared/IVersionable.sol";
-import {Versionable} from "../shared/Versionable.sol";
-
-import {Timestamp, zeroTimestamp} from "../type/Timestamp.sol";
-import {UFixed, UFixedLib} from "../type/UFixed.sol";
-import {Blocknumber, blockNumber} from "../type/Blocknumber.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
 import {ObjectType, INSTANCE, PRODUCT, POOL, POLICY, REGISTRY} from "../type/ObjectType.sol";
-import {APPLIED, ACTIVE, KEEP_STATE} 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 {KEEP_STATE} from "../type/StateId.sol";
+import {NftId} from "../type/NftId.sol";
 import {RiskId} from "../type/RiskId.sol";
 import {StateId} from "../type/StateId.sol";
-import {Version, VersionLib} from "../type/Version.sol";
-import {RoleId, PRODUCT_OWNER_ROLE} from "../type/RoleId.sol";
-
-import {IService} from "../shared/IService.sol";
-import {Service} from "../shared/Service.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
-import {IProductService} from "./IProductService.sol";
-import {IRegistryService} from "../registry/IRegistryService.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
-import {IPoolService} from "../pool/PoolService.sol";
 
-contract ProductService is
+contract RiskService is
     ComponentVerifyingService,
-    IProductService 
+    IRiskService 
 {
     IInstanceService private _instanceService;
     IPoolService internal _poolService;
     IRegistryService private _registryService;
 
-    event LogProductServiceSender(address sender);
-
     function _initialize(
         address owner, 
         bytes memory data
@@ -71,7 +44,7 @@ contract ProductService is
         _poolService = IPoolService(getRegistry().getServiceAddress(POOL(), getVersion().toMajorPart()));
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
 
-        registerInterface(type(IProductService).interfaceId);
+        registerInterface(type(IRiskService).interfaceId);
     }
 
 

package/contracts/product/RiskServiceManager.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
+import {RiskService} from "./RiskService.sol";
+
+contract RiskServiceManager is ProxyManager {
+
+    RiskService private _riskService;
+
+    /// @dev initializes proxy manager with product service implementation 
+    constructor(
+        address authority, 
+        address registryAddress,
+        bytes32 salt
+    ) 
+        ProxyManager(registryAddress)
+    {
+        RiskService svc = new RiskService{salt: salt}();
+        bytes memory data = abi.encode(registryAddress, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
+            address(svc), 
+            data,
+            salt);
+
+        _riskService = RiskService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getRiskService()
+        external
+        view
+        returns (RiskService riskService)
+    {
+        return _riskService;
+    }
+
+}

package/contracts/registry/IRegistry.sol

@@ -88,7 +88,7 @@ interface IRegistry is IERC165 {
 
     function getObjectCount() external view returns (uint256);
 
-    function getNftId(address objectAddress) external view returns (NftId nftId);
+    function getNftIdForAddress(address objectAddress) external view returns (NftId nftId);
 
     function ownerOf(NftId nftId) external view returns (address);
 

package/contracts/registry/Registry.sol

@@ -247,7 +247,7 @@ contract Registry is
         return _protocolNftId;
     }
 
-    function getNftId(address object) external view returns (NftId id) {
+    function getNftIdForAddress(address object) external view returns (NftId id) {
         return _nftIdByAddress[object];
     }
 

package/contracts/registry/RegistryAdmin.sol

@@ -12,6 +12,7 @@ import {ReleaseRegistry} from "./ReleaseRegistry.sol";
 import {RoleId, RoleIdLib, ADMIN_ROLE, GIF_MANAGER_ROLE, GIF_ADMIN_ROLE, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {StakingStore} from "../staking/StakingStore.sol";
 import {STAKING} from "../type/ObjectType.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
 import {TokenRegistry} from "./TokenRegistry.sol";
 import {VersionPart} from "../type/Version.sol";
 
@@ -359,7 +360,15 @@ contract RegistryAdmin is
         functions[12] = toFunction(StakingStore.claimUpTo.selector, "claimUpTo");
         functions[13] = toFunction(StakingStore.unstakeUpTo.selector, "unstakeUpTo");
         _authorizeTargetFunctions(_stakingStore, stakingRoleId, functions);
-
+        
         _grantRoleToAccount(stakingRoleId, _staking);
+    
+        // grant token handler authorizations
+        IStaking staking = IStaking(_staking);
+        functions = new FunctionInfo[](2);
+        functions[0] = toFunction(TokenHandler.collectTokens.selector, "collectTokens");
+        functions[1] = toFunction(TokenHandler.distributeTokens.selector, "distributeTokens");
+        
+        _authorizeTargetFunctions(address(staking.getTokenHandler()), stakingRoleId, functions);
     }
 }

package/contracts/registry/RegistryService.sol

@@ -1,32 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-// import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
-
-import {IRegistry} from "./IRegistry.sol";
-import {IInstance} from "../instance/IInstance.sol";
-
 import {IComponent} from "../../contracts/shared/IComponent.sol";
+import {IDistributionComponent} from "../../contracts/distribution/IDistributionComponent.sol";
+import {IInstance} from "../instance/IInstance.sol";
 import {IPoolComponent} from "../../contracts/pool/IPoolComponent.sol";
 import {IProductComponent} from "../../contracts/product/IProductComponent.sol";
-import {IDistributionComponent} from "../../contracts/distribution/IDistributionComponent.sol";
-
-import {IVersionable} from "../../contracts/shared/IVersionable.sol";
-import {Versionable} from "../../contracts/shared/Versionable.sol";
 import {IRegisterable} from "../../contracts/shared/IRegisterable.sol";
+import {IRegistry} from "./IRegistry.sol";
+import {IRegistryService} from "./IRegistryService.sol";
 
-import {RoleId, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE, ORACLE_OWNER_ROLE} from "../../contracts/type/RoleId.sol";
 import {ObjectType, REGISTRY, SERVICE, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKE, STAKING, PRICE} from "../../contracts/type/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED} from "../../contracts/type/StateId.sol";
 import {NftId, NftIdLib} from "../../contracts/type/NftId.sol";
-import {Fee, FeeLib} from "../../contracts/type/Fee.sol";
-import {Version, VersionPart, VersionLib} from "../../contracts/type/Version.sol";
-
 import {Service} from "../shared/Service.sol";
-import {IService} from "../shared/IService.sol";
-import {IRegistryService} from "./IRegistryService.sol";
-import {Registry} from "./Registry.sol";
 
 contract RegistryService is
     Service,