@etherisc/gif-next 0.0.2-e83e4a5-207 → 0.0.2-e876b87-961

package/contracts/product/Product.sol

@@ -1,37 +1,36 @@
 // 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";
+import {IComponent} from "../shared/IComponent.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {IRisk} from "../instance/module/IRisk.sol";
 import {IApplicationService} from "./IApplicationService.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.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 {ObjectType, COMPONENT, DISTRIBUTION, ORACLE, POOL, PRODUCT, BUNDLE, APPLICATION, POLICY, CLAIM, PRICE } from "../type/ObjectType.sol";
 import {PayoutId} from "../type/PayoutId.sol";
-import {COMPONENT, PRODUCT, APPLICATION, POLICY, CLAIM, PRICE } from "../type/ObjectType.sol";
+import {COMPONENT, PRODUCT, APPLICATION, POLICY, CLAIM, PRICE, BUNDLE } from "../type/ObjectType.sol";
 import {ReferralId} from "../type/Referral.sol";
 import {RiskId, RiskIdLib} from "../type/RiskId.sol";
 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";
-import {Distribution} from "../distribution/Distribution.sol";
+import {IDistributionComponent} from "../distribution/IDistributionComponent.sol";
+import {IOracleComponent} from "../oracle/IOracleComponent.sol";
+import {IPoolComponent} from "../pool/IPoolComponent.sol";
 
 abstract contract Product is
     InstanceLinkedComponent, 
@@ -41,16 +40,39 @@ abstract contract Product is
     bytes32 public constant PRODUCT_STORAGE_LOCATION_V1 = 0x0bb7aafdb8e380f81267337bc5b5dfdf76e6d3a380ecadb51ec665246d9d6800;
 
     struct ProductStorage {
-        IProductService _productService;
+        bool _isProcessingFundedClaims;
+        bool _hasDistribution;
+        uint8 _numberOfOracles;
+        IRiskService _riskService;
         IApplicationService _applicationService;
         IPolicyService _policyService;
         IClaimService _claimService;
         IPricingService _pricingService;
         IComponentService _componentService;
-        NftId _poolNftId;
-        NftId _distributionNftId;
-        Pool _pool;
-        Distribution _distribution;
+    }
+
+
+    function registerComponent(address component)
+        external
+        virtual
+        onlyOwner()
+        returns (NftId componentNftId)
+    {
+        return _getProductStorage()._componentService.registerComponent(component);
+    }
+
+
+    function processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    )
+        external
+        virtual
+        restricted() // pool service role
+        onlyNftOfType(policyNftId, POLICY())
+    {
+        // default implementation does nothing
     }
 
 
@@ -62,12 +84,13 @@ abstract contract Product is
         NftId bundleNftId,
         ReferralId referralId
     )
-        external 
+        public 
         view 
         override 
+        onlyNftOfType(bundleNftId, BUNDLE())
         returns (Amount premiumAmount)
     {
-        IPolicy.Premium memory premium = _getProductStorage()._pricingService.calculatePremium(
+        IPolicy.PremiumInfo memory premium = _getProductStorage()._pricingService.calculatePremium(
             getNftId(),
             riskId,
             sumInsuredAmount,
@@ -77,14 +100,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
@@ -96,15 +119,6 @@ abstract contract Product is
     }
 
 
-    function register()
-        external
-        virtual
-        onlyOwner()
-    {
-        _getProductStorage()._componentService.registerProduct();
-    }
-
-
     function getInitialProductInfo()
         public 
         virtual 
@@ -114,8 +128,13 @@ abstract contract Product is
         ProductStorage storage $ = _getProductStorage();
 
         return IComponents.ProductInfo({
-            distributionNftId: $._distributionNftId,
-            poolNftId: $._poolNftId,
+            isProcessingFundedClaims: false,
+            hasDistribution: $._hasDistribution,
+            expectedNumberOfOracles: $._numberOfOracles,
+            numberOfOracles: 0,
+            poolNftId: NftIdLib.zero(),
+            distributionNftId: NftIdLib.zero(),
+            oracleNftId: new NftId[]($._numberOfOracles),
             productFee: FeeLib.zero(),
             processingFee: FeeLib.zero(),
             distributionFee: FeeLib.zero(),
@@ -126,14 +145,6 @@ abstract contract Product is
         });
     }
 
-    function getPoolNftId() external view override returns (NftId poolNftId) {
-        return getRegistry().getNftId(address(_getProductStorage()._pool));
-    }
-
-    function getDistributionNftId() external view override returns (NftId distributionNftId) {
-        return getRegistry().getNftId(address(_getProductStorage()._distribution));
-    }
-
 
     function _initializeProduct(
         address registry,
@@ -143,9 +154,9 @@ abstract contract Product is
         string memory name,
         address token,
         bool isInterceptor,
-        address pool,
-        address distribution,
-        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bool isProcessingFundedClaims,
+        bool hasDistribution,
+        uint8 numberOfOracles,
         bytes memory componentData // writeonly data that will saved in the object info record of the registry
     )
         internal
@@ -161,24 +172,20 @@ abstract contract Product is
             authorization, 
             isInterceptor, 
             initialOwner, 
-            registryData, 
             componentData);
 
         ProductStorage storage $ = _getProductStorage();
-        // TODO add validation
-        // TODO refactor to go via registry ?
-        $._productService = IProductService(_getServiceAddress(PRODUCT())); 
+        $._isProcessingFundedClaims = isProcessingFundedClaims;
+        $._hasDistribution = hasDistribution;
+        $._numberOfOracles = numberOfOracles;
+        $._riskService = IRiskService(_getServiceAddress(PRODUCT())); 
         $._applicationService = IApplicationService(_getServiceAddress(APPLICATION())); 
         $._policyService = IPolicyService(_getServiceAddress(POLICY())); 
         $._claimService = IClaimService(_getServiceAddress(CLAIM())); 
         $._pricingService = IPricingService(_getServiceAddress(PRICE()));
         $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
-        $._pool = Pool(pool);
-        $._distribution = Distribution(distribution);
-        $._poolNftId = getRegistry().getNftId(pool);
-        $._distributionNftId = getRegistry().getNftId(distribution);
 
-        registerInterface(type(IProductComponent).interfaceId);  
+        _registerInterface(type(IProductComponent).interfaceId);  
     }
 
 
@@ -196,8 +203,11 @@ abstract contract Product is
     function _createRisk(
         RiskId id,
         bytes memory data
-    ) internal {
-        _getProductService().createRisk(
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._riskService.createRisk(
             id,
             data
         );
@@ -206,8 +216,11 @@ abstract contract Product is
     function _updateRisk(
         RiskId id,
         bytes memory data
-    ) internal {
-        _getProductService().updateRisk(
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._riskService.updateRisk(
             id,
             data
         );
@@ -216,15 +229,18 @@ abstract contract Product is
     function _updateRiskState(
         RiskId id,
         StateId state
-    ) internal {
-        _getProductService().updateRiskState(
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._riskService.updateRiskState(
             id,
             state
         );
     }
 
 
-    function _getRiskInfo(RiskId id) internal view returns (IRisk.RiskInfo memory info) {
+    function _getRiskInfo(RiskId id) internal virtual view returns (IRisk.RiskInfo memory info) {
         return getInstance().getInstanceReader().getRiskInfo(id);
     }
 
@@ -233,18 +249,21 @@ abstract contract Product is
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
         bytes memory applicationData
     )
         internal
+        virtual
         returns (NftId applicationNftId) 
     {
         return _getProductStorage()._applicationService.create(
             applicationOwner,
             riskId,
             sumInsuredAmount,
+            premiumAmount,
             lifetime,
             bundleNftId,
             referralId,
@@ -252,24 +271,45 @@ abstract contract Product is
         );
     }
 
-    function _collateralize(
-        NftId policyNftId,
-        bool requirePremiumPayment,
+    function _createPolicy(
+        NftId applicationNftId,
         Timestamp activateAt
     )
         internal
+        virtual
     {
-        _getProductStorage()._policyService.collateralize(
-            policyNftId, 
-            requirePremiumPayment, 
+        _getProductStorage()._policyService.createPolicy(
+            applicationNftId, 
             activateAt);
     }
 
+    function _decline(
+        NftId policyNftId
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._policyService.decline(
+            policyNftId);
+    }
+
+    function _expire(
+        NftId policyNftId,
+        Timestamp expireAt
+    )
+        internal
+        virtual
+        returns (Timestamp expiredAt)
+    {
+        expiredAt = _getProductStorage()._policyService.expire(policyNftId, expireAt);
+    }
+
     function _collectPremium(
         NftId policyNftId,
         Timestamp activateAt
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.collectPremium(
             policyNftId, 
@@ -281,6 +321,7 @@ abstract contract Product is
         Timestamp activateAt
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.activate(
             policyNftId, 
@@ -291,6 +332,7 @@ abstract contract Product is
         NftId policyNftId
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.close(
             policyNftId);
@@ -302,6 +344,7 @@ abstract contract Product is
         bytes memory claimData
     )
         internal
+        virtual
         returns(ClaimId)
     {
         return _getProductStorage()._claimService.submit(
@@ -317,6 +360,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.confirm(
             policyNftId,
@@ -331,6 +375,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.decline(
             policyNftId,
@@ -343,6 +388,7 @@ abstract contract Product is
         ClaimId claimId
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.close(
             policyNftId,
@@ -356,6 +402,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
         returns (PayoutId)
     {
         return _getProductStorage()._claimService.createPayout(
@@ -365,28 +412,44 @@ abstract contract Product is
             data);
     }
 
+    function _createPayoutForBeneficiary(
+        NftId policyNftId,
+        ClaimId claimId,
+        Amount amount,
+        address beneficiary,
+        bytes memory data
+    )
+        internal
+        virtual
+        returns (PayoutId)
+    {
+        return _getProductStorage()._claimService.createPayoutForBeneficiary(
+            policyNftId, 
+            claimId, 
+            amount, 
+            beneficiary,
+            data);
+    }
+
     function _processPayout(
         NftId policyNftId,
         PayoutId payoutId
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.processPayout(
             policyNftId,
             payoutId);
     }
 
-    function _toRiskId(string memory riskName) internal pure returns (RiskId riskId) {
+    function _toRiskId(string memory riskName) internal virtual pure returns (RiskId riskId) {
         return RiskIdLib.toRiskId(riskName);
     }
 
-    function _getProductStorage() private pure returns (ProductStorage storage $) {
+    function _getProductStorage() internal virtual pure returns (ProductStorage storage $) {
         assembly {
             $.slot := PRODUCT_STORAGE_LOCATION_V1
         }
     }
-
-    function _getProductService() internal view returns (IProductService) {
-        return _getProductStorage()._productService;
-    }
 }

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
@@ -60,18 +33,17 @@ contract ProductService is
         virtual override
     {
         (
-            address registryAddress,, 
-            //address managerAddress
+            address registryAddress,
             address authority
-        ) = abi.decode(data, (address, address, address));
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, authority, owner);
+        _initializeService(registryAddress, authority, owner);
 
         _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
         _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 registry,
+        bytes32 salt
+    ) 
+    {
+        RiskService svc = new RiskService{salt: salt}();
+        bytes memory data = abi.encode(registry, authority);
+        IVersionable versionable = initialize(
+            registry,
+            address(svc), 
+            data,
+            salt);
+
+        _riskService = RiskService(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getRiskService()
+        external
+        view
+        returns (RiskService riskService)
+    {
+        return _riskService;
+    }
+
+}