@etherisc/gif-next 0.0.2-c6d46bb-892 → 0.0.2-c75d1c9-837

package/contracts/product/Product.sol

@@ -1,115 +1,194 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {ClaimId} from "../type/ClaimId.sol";
-import {Component} from "../shared/Component.sol";
 import {Fee} 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 {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 {COMPONENT, PRODUCT, BUNDLE, APPLICATION, POLICY, CLAIM, PRICE } from "../type/ObjectType.sol";
 import {PayoutId} from "../type/PayoutId.sol";
-import {PRODUCT, APPLICATION, POLICY, CLAIM, PRICE } from "../type/ObjectType.sol";
+import {COMPONENT, PRODUCT, APPLICATION, POLICY, CLAIM, PRICE, BUNDLE, RISK } 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 {ISetup} from "../instance/module/ISetup.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {Pool} from "../pool/Pool.sol";
-import {Distribution} from "../distribution/Distribution.sol";
 
 abstract contract Product is
-    Component, 
+    InstanceLinkedComponent, 
     IProductComponent
 {
     // keccak256(abi.encode(uint256(keccak256("etherisc.storage.Product")) - 1)) & ~bytes32(uint256(0xff));
     bytes32 public constant PRODUCT_STORAGE_LOCATION_V1 = 0x0bb7aafdb8e380f81267337bc5b5dfdf76e6d3a380ecadb51ec665246d9d6800;
 
     struct ProductStorage {
-        IProductService _productService;
+        IComponents.ProductInfo _productInfo;
+        IComponents.FeeInfo _feeInfo;
+        IComponentService _componentService;
+        IRiskService _riskService;
         IApplicationService _applicationService;
         IPolicyService _policyService;
         IClaimService _claimService;
         IPricingService _pricingService;
-        Pool _pool;
-        Distribution _distribution;
-        Fee _initialProductFee;
-        Fee _initialProcessingFee;
-        TokenHandler _tokenHandler;
-        NftId _poolNftId;
-        NftId _distributionNftId;
     }
 
-    function initializeProduct(
+
+    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
+    }
+
+
+    function calculatePremium(
+        Amount sumInsuredAmount,
+        RiskId riskId,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    )
+        public 
+        view 
+        override 
+        onlyNftOfType(bundleNftId, BUNDLE())
+        returns (Amount premiumAmount)
+    {
+        IPolicy.PremiumInfo memory premium = _getProductStorage()._pricingService.calculatePremium(
+            getNftId(),
+            riskId,
+            sumInsuredAmount,
+            lifetime,
+            applicationData,
+            bundleNftId,
+            referralId
+        );
+
+        return premium.premiumAmount;
+    }
+
+    function calculateNetPremium(
+        Amount sumInsuredAmount,
+        RiskId,
+        Seconds,
+        bytes memory
+    )
+        external
+        view
+        virtual override
+        returns (Amount netPremiumAmount)
+    {
+        // default 10% of sum insured
+        return AmountLib.toAmount(sumInsuredAmount.toInt() / 10);
+    }
+
+
+    function getInitialProductInfo()
+        public 
+        virtual 
+        view 
+        returns (IComponents.ProductInfo memory poolInfo)
+    {
+        return _getProductStorage()._productInfo;
+    }
+
+    function getInitialFeeInfo()
+        public 
+        virtual 
+        view 
+        returns (IComponents.FeeInfo memory feeInfo)
+    {
+        return _getProductStorage()._feeInfo;
+    }
+
+
+    function _initializeProduct(
         address registry,
         NftId instanceNftId,
         string memory name,
-        address token,
-        bool isInterceptor,
-        address pool,
-        address distribution,
-        Fee memory productFee,
-        Fee memory processingFee,
+        IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
+        IAuthorization authorization,
         address initialOwner,
-        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
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeComponent(registry, instanceNftId, name, token, PRODUCT(), isInterceptor, initialOwner, registryData);
+        _initializeInstanceLinkedComponent(
+            registry, 
+            instanceNftId, 
+            name, 
+            PRODUCT(), 
+            authorization, 
+            productInfo.isInterceptingPolicyTransfers, 
+            initialOwner, 
+            componentData);
 
         ProductStorage storage $ = _getProductStorage();
-        // TODO add validation
-        // TODO refactor to go via registry ?
-        $._productService = IProductService(_getServiceAddress(PRODUCT())); 
+        $._productInfo = productInfo;
+        $._feeInfo = feeInfo;
+        $._riskService = IRiskService(_getServiceAddress(RISK())); 
         $._applicationService = IApplicationService(_getServiceAddress(APPLICATION())); 
         $._policyService = IPolicyService(_getServiceAddress(POLICY())); 
         $._claimService = IClaimService(_getServiceAddress(CLAIM())); 
         $._pricingService = IPricingService(_getServiceAddress(PRICE()));
-        $._pool = Pool(pool);
-        $._distribution = Distribution(distribution);
-        $._initialProductFee = productFee;
-        $._initialProcessingFee = processingFee;  
-        $._tokenHandler = new TokenHandler(token);
-        $._poolNftId = getRegistry().getNftId(pool);
-        $._distributionNftId = getRegistry().getNftId(distribution);
-
-        registerInterface(type(IProductComponent).interfaceId);  
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
+
+        _registerInterface(type(IProductComponent).interfaceId);  
     }
 
-    // from product component
-    function setFees(
+
+    function _setFees(
         Fee memory productFee,
         Fee memory processingFee
     )
-        external
-        onlyOwner
-        restricted()
-        override
+        internal
+        virtual
     {
-        _getProductService().setFees(productFee, processingFee);
+        _getProductStorage()._componentService.setProductFees(productFee, processingFee);
     }
 
+
     function _createRisk(
-        RiskId id,
+        bytes32 id,
         bytes memory data
-    ) internal {
-        _getProductService().createRisk(
+    )
+        internal
+        virtual
+        returns (RiskId riskId)
+    {
+        return _getProductStorage()._riskService.createRisk(
             id,
             data
         );
@@ -118,8 +197,11 @@ abstract contract Product is
     function _updateRisk(
         RiskId id,
         bytes memory data
-    ) internal {
-        _getProductService().updateRisk(
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._riskService.updateRisk(
             id,
             data
         );
@@ -128,33 +210,36 @@ 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) {
-        return getInstance().getInstanceReader().getRiskInfo(id);
-    }
 
     function _createApplication(
         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,
@@ -162,16 +247,52 @@ abstract contract Product is
         );
     }
 
-    function _collateralize(
+    function _createPolicy(
+        NftId applicationNftId,
+        Timestamp activateAt
+    )
+        internal
+        virtual
+        returns (Amount premiumAmount)
+    {
+        premiumAmount = _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);
+    }
+
+    /// @dev adjust the activation date of the policy. 
+    /// The policy must already have an activation date set.
+    /// Allowed values are from the current blocktime to the expiration date of the policy.
+    function _adjustActivation(
         NftId policyNftId,
-        bool requirePremiumPayment,
         Timestamp activateAt
     )
         internal
+        virtual
     {
-        _getProductStorage()._policyService.collateralize(
+        _getProductStorage()._policyService.adjustActivation(
             policyNftId, 
-            requirePremiumPayment, 
             activateAt);
     }
 
@@ -180,6 +301,7 @@ abstract contract Product is
         Timestamp activateAt
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.collectPremium(
             policyNftId, 
@@ -191,6 +313,7 @@ abstract contract Product is
         Timestamp activateAt
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.activate(
             policyNftId, 
@@ -201,6 +324,7 @@ abstract contract Product is
         NftId policyNftId
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.close(
             policyNftId);
@@ -212,6 +336,7 @@ abstract contract Product is
         bytes memory claimData
     )
         internal
+        virtual
         returns(ClaimId)
     {
         return _getProductStorage()._claimService.submit(
@@ -220,6 +345,18 @@ abstract contract Product is
             claimData);
     }
 
+    function _revokeClaim(
+        NftId policyNftId,
+        ClaimId claimId
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._claimService.revoke(
+            policyNftId,
+            claimId);
+    }
+
     function _confirmClaim(
         NftId policyNftId,
         ClaimId claimId,
@@ -227,6 +364,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.confirm(
             policyNftId,
@@ -241,6 +379,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.decline(
             policyNftId,
@@ -253,6 +392,7 @@ abstract contract Product is
         ClaimId claimId
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.close(
             policyNftId,
@@ -266,6 +406,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
         returns (PayoutId)
     {
         return _getProductStorage()._claimService.createPayout(
@@ -275,105 +416,52 @@ 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 calculatePremium(
-        Amount sumInsuredAmount,
-        RiskId riskId,
-        Seconds lifetime,
-        bytes memory applicationData,
-        NftId bundleNftId,
-        ReferralId referralId
-    )
-        external 
-        view 
-        override 
-        returns (Amount premiumAmount)
-    {
-        IPolicy.Premium memory premium = _getProductStorage()._pricingService.calculatePremium(
-            getNftId(),
-            riskId,
-            sumInsuredAmount,
-            lifetime,
-            applicationData,
-            bundleNftId,
-            referralId
-        );
-
-        return AmountLib.toAmount(premium.premiumAmount);
-    }
-
-    function calculateNetPremium(
-        Amount sumInsuredAmount,
-        RiskId riskId,
-        Seconds lifetime,
-        bytes memory applicationData
+    function _cancelPayout(
+        NftId policyNftId,
+        PayoutId payoutId
     )
-        external
-        view
-        virtual override
-        returns (Amount netPremiumAmount)
+        internal
+        virtual
     {
-        // default 10% of sum insured
-        return AmountLib.toAmount(sumInsuredAmount.toInt() / 10);
-    }
-
-    function _toRiskId(string memory riskName) internal pure returns (RiskId riskId) {
-        return RiskIdLib.toRiskId(riskName);
-    }
-
-    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 getSetupInfo() public view returns (ISetup.ProductSetupInfo memory setupInfo) {
-        InstanceReader reader = getInstance().getInstanceReader();
-        setupInfo = reader.getProductSetupInfo(getNftId());
-
-        // fallback to initial setup info (wallet is always != address(0))
-        if(setupInfo.wallet == address(0)) {
-            setupInfo = _getInitialSetupInfo();
-        }
-    }
-
-    function _getInitialSetupInfo() internal view returns (ISetup.ProductSetupInfo memory setupInfo) {
-        ProductStorage storage $ = _getProductStorage();
-
-        ISetup.DistributionSetupInfo memory distributionSetupInfo = $._distribution.getSetupInfo();
-        IComponents.PoolInfo memory poolInfo = $._pool.getPoolInfo();
-
-        return ISetup.ProductSetupInfo(
-            getToken(),
-            $._tokenHandler,
-            $._distributionNftId,
-            $._poolNftId,
-            $._initialProductFee,
-            $._initialProcessingFee,
-            false,
-            getWallet()
-        );
+        _getProductStorage()._claimService.cancelPayout(
+            policyNftId,
+            payoutId);
     }
 
-    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;
-    }
 }