@etherisc/gif-next 0.0.2-c04bff4-304 → 0.0.2-c0923b6-664

package/contracts/product/Product.sol

@@ -3,30 +3,28 @@ pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {ClaimId} from "../type/ClaimId.sol";
-import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
-import {IRisk} from "../instance/module/IRisk.sol";
+import {Fee} from "../type/Fee.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 {IRiskService} from "./IRiskService.sol";
 import {IClaimService} from "./IClaimService.sol";
 import {IPricingService} from "./IPricingService.sol";
 import {IProductComponent} from "./IProductComponent.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 {COMPONENT, 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 {RiskId} from "../type/RiskId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {StateId} from "../type/StateId.sol";
 import {Timestamp} from "../type/Timestamp.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";
 
 abstract contract Product is
     InstanceLinkedComponent, 
@@ -36,16 +34,39 @@ abstract contract Product is
     bytes32 public constant PRODUCT_STORAGE_LOCATION_V1 = 0x0bb7aafdb8e380f81267337bc5b5dfdf76e6d3a380ecadb51ec665246d9d6800;
 
     struct ProductStorage {
+        IComponents.ProductInfo _productInfo;
+        IComponents.FeeInfo _feeInfo;
+        IComponentService _componentService;
         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
+        restricted()
+        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
     }
 
 
@@ -59,7 +80,9 @@ abstract contract Product is
     )
         public 
         view 
+        virtual
         override 
+        onlyNftOfType(bundleNftId, BUNDLE())
         returns (Amount premiumAmount)
     {
         IPolicy.PremiumInfo memory premium = _getProductStorage()._pricingService.calculatePremium(
@@ -91,88 +114,56 @@ abstract contract Product is
     }
 
 
-    function register()
-        external
-        virtual
-        onlyOwner()
-    {
-        _getProductStorage()._componentService.registerProduct();
-        _approveTokenHandler(type(uint256).max);
-    }
-
-
     function getInitialProductInfo()
         public 
         virtual 
         view 
         returns (IComponents.ProductInfo memory poolInfo)
     {
-        ProductStorage storage $ = _getProductStorage();
-
-        return IComponents.ProductInfo({
-            distributionNftId: $._distributionNftId,
-            poolNftId: $._poolNftId,
-            productFee: FeeLib.zero(),
-            processingFee: FeeLib.zero(),
-            distributionFee: FeeLib.zero(),
-            minDistributionOwnerFee: FeeLib.zero(),
-            poolFee: FeeLib.zero(),
-            stakingFee: FeeLib.zero(),
-            performanceFee: FeeLib.zero()
-        });
+        return _getProductStorage()._productInfo;
     }
 
-    function getPoolNftId() external view override returns (NftId poolNftId) {
-        return getRegistry().getNftIdForAddress(address(_getProductStorage()._pool));
+    function getInitialFeeInfo()
+        public 
+        virtual 
+        view 
+        returns (IComponents.FeeInfo memory feeInfo)
+    {
+        return _getProductStorage()._feeInfo;
     }
 
-    function getDistributionNftId() external view override returns (NftId distributionNftId) {
-        return getRegistry().getNftIdForAddress(address(_getProductStorage()._distribution));
-    }
 
-    function _initializeProduct(
+    function __Product_init(
         address registry,
         NftId instanceNftId,
-        IAuthorization authorization,
-        address initialOwner,
         string memory name,
-        address token,
-        bool isInterceptor,
-        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
+        IComponents.ProductInfo memory productInfo,
+        IComponents.FeeInfo memory feeInfo,
+        IAuthorization authorization,
+        address initialOwner
     )
         internal
         virtual
         onlyInitializing()
     {
-        _initializeInstanceLinkedComponent(
+        __InstanceLinkedComponent_init(
             registry, 
             instanceNftId, 
             name, 
-            token, 
             PRODUCT(), 
             authorization, 
-            isInterceptor, 
-            initialOwner, 
-            registryData, 
-            componentData);
+            productInfo.isInterceptingPolicyTransfers, 
+            initialOwner);
 
         ProductStorage storage $ = _getProductStorage();
-        // TODO add validation
-        // TODO refactor to go via registry for all components linked to this product (#527)
-        $._riskService = IRiskService(_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()));
         $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
-        $._pool = Pool(pool);
-        $._distribution = Distribution(distribution);
-        $._poolNftId = getRegistry().getNftIdForAddress(pool);
-        $._distributionNftId = getRegistry().getNftIdForAddress(distribution);
 
         _registerInterface(type(IProductComponent).interfaceId);  
     }
@@ -190,10 +181,14 @@ abstract contract Product is
 
 
     function _createRisk(
-        RiskId id,
+        bytes32 id,
         bytes memory data
-    ) internal {
-        _getRiskService().createRisk(
+    )
+        internal
+        virtual
+        returns (RiskId riskId)
+    {
+        return _getProductStorage()._riskService.createRisk(
             id,
             data
         );
@@ -202,26 +197,38 @@ abstract contract Product is
     function _updateRisk(
         RiskId id,
         bytes memory data
-    ) internal {
-        _getRiskService().updateRisk(
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._riskService.updateRisk(
             id,
             data
         );
     }
 
-    function _updateRiskState(
+    function _setRiskLocked(
         RiskId id,
-        StateId state
-    ) internal {
-        _getRiskService().updateRiskState(
+        bool locked
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._riskService.setRiskLocked(
             id,
-            state
+            locked
         );
     }
 
-
-    function _getRiskInfo(RiskId id) internal view returns (IRisk.RiskInfo memory info) {
-        return getInstance().getInstanceReader().getRiskInfo(id);
+    function _closeRisk(
+        RiskId id
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._riskService.closeRisk(
+            id
+        );
     }
 
 
@@ -236,6 +243,7 @@ abstract contract Product is
         bytes memory applicationData
     )
         internal
+        virtual
         returns (NftId applicationNftId) 
     {
         return _getProductStorage()._applicationService.create(
@@ -250,21 +258,36 @@ abstract contract Product is
         );
     }
 
+    function _revoke(
+        NftId applicationNftId
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._applicationService.revoke(
+            applicationNftId);
+    }
+
     function _createPolicy(
         NftId applicationNftId,
-        Timestamp activateAt
+        Timestamp activateAt,
+        Amount maxPremiumAmount
     )
         internal
+        virtual
+        returns (Amount premiumAmount)
     {
-        _getProductStorage()._policyService.createPolicy(
+        premiumAmount = _getProductStorage()._policyService.createPolicy(
             applicationNftId, 
-            activateAt);
+            activateAt,
+            maxPremiumAmount);
     }
 
     function _decline(
         NftId policyNftId
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.decline(
             policyNftId);
@@ -275,16 +298,33 @@ abstract contract Product is
         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,
+        Timestamp activateAt
+    )
+        internal
+        virtual
+    {
+        _getProductStorage()._policyService.adjustActivation(
+            policyNftId, 
+            activateAt);
+    }
+
     function _collectPremium(
         NftId policyNftId,
         Timestamp activateAt
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.collectPremium(
             policyNftId, 
@@ -296,6 +336,7 @@ abstract contract Product is
         Timestamp activateAt
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.activate(
             policyNftId, 
@@ -306,6 +347,7 @@ abstract contract Product is
         NftId policyNftId
     )
         internal
+        virtual
     {
         _getProductStorage()._policyService.close(
             policyNftId);
@@ -317,6 +359,7 @@ abstract contract Product is
         bytes memory claimData
     )
         internal
+        virtual
         returns(ClaimId)
     {
         return _getProductStorage()._claimService.submit(
@@ -325,6 +368,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,
@@ -332,6 +387,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.confirm(
             policyNftId,
@@ -346,6 +402,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
     {
         _getProductStorage()._claimService.decline(
             policyNftId,
@@ -353,13 +410,14 @@ abstract contract Product is
             data);
     }
 
-    function _closeClaim(
+    function _cancelConfirmedClaim(
         NftId policyNftId,
         ClaimId claimId
     )
         internal
+        virtual
     {
-        _getProductStorage()._claimService.close(
+        _getProductStorage()._claimService.cancelConfirmedClaim(
             policyNftId,
             claimId);
     }
@@ -371,6 +429,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
         returns (PayoutId)
     {
         return _getProductStorage()._claimService.createPayout(
@@ -388,6 +447,7 @@ abstract contract Product is
         bytes memory data
     )
         internal
+        virtual
         returns (PayoutId)
     {
         return _getProductStorage()._claimService.createPayoutForBeneficiary(
@@ -403,23 +463,29 @@ abstract contract Product is
         PayoutId payoutId
     )
         internal
+        virtual
+        returns (Amount netPayoutAmount, Amount processingFeeAmount)
     {
-        _getProductStorage()._claimService.processPayout(
+        (netPayoutAmount, processingFeeAmount) = _getProductStorage()._claimService.processPayout(
             policyNftId,
             payoutId);
     }
 
-    function _toRiskId(string memory riskName) internal pure returns (RiskId riskId) {
-        return RiskIdLib.toRiskId(riskName);
+    function _cancelPayout(
+        NftId policyNftId,
+        PayoutId payoutId
+    )
+        internal
+        virtual
+    {
+        _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 _getRiskService() internal view returns (IRiskService) {
-        return _getProductStorage()._riskService;
-    }
 }

package/contracts/product/RiskService.sol

@@ -2,27 +2,24 @@
 pragma solidity ^0.8.20;
 
 import {IInstance} from "../instance/IInstance.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 {IRegistry} from "../registry/IRegistry.sol";
 import {IRisk} from "../instance/module/IRisk.sol";
+import {IRiskService} from "./IRiskService.sol";
 
+import {ContractLib} from "../shared/ContractLib.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
-import {ObjectType, INSTANCE, PRODUCT, POOL, POLICY, REGISTRY} from "../type/ObjectType.sol";
-import {KEEP_STATE} from "../type/StateId.sol";
+import {ObjectType, COMPONENT, PRODUCT, RISK} from "../type/ObjectType.sol";
+import {ACTIVE, KEEP_STATE, CLOSED} from "../type/StateId.sol";
 import {NftId} from "../type/NftId.sol";
-import {RiskId} from "../type/RiskId.sol";
-import {StateId} from "../type/StateId.sol";
-import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {RiskId, RiskIdLib} from "../type/RiskId.sol";
+import {RiskSet} from "../instance/RiskSet.sol";
+import {Service} from "../shared/Service.sol";
+import {TimestampLib} from "../type/Timestamp.sol";
 
 contract RiskService is
-    ComponentVerifyingService,
+    Service,
     IRiskService 
 {
-    IInstanceService private _instanceService;
-    IPoolService internal _poolService;
-    IRegistryService private _registryService;
 
     function _initialize(
         address owner, 
@@ -33,35 +30,44 @@ contract RiskService is
         virtual override
     {
         (
-            address registryAddress,, 
-            //address managerAddress
-            address authority
-        ) = abi.decode(data, (address, address, address));
-
-        _initializeService(registryAddress, authority, owner);
-
-        _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
-        _poolService = IPoolService(getRegistry().getServiceAddress(POOL(), getVersion().toMajorPart()));
-        _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
 
+        __Service_init(authority, registry, owner);
         _registerInterface(type(IRiskService).interfaceId);
     }
 
-
+    /// @inheritdoc IRiskService
     function createRisk(
-        RiskId riskId,
+        bytes32 id,
         bytes memory data
     )
         external 
-        override
+        virtual
+        restricted()
+        returns (RiskId riskId)
     {
-        (NftId productNftId,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
-        IRisk.RiskInfo memory riskInfo = IRisk.RiskInfo(productNftId, data);
+        // checks
+        (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
+
+        // effects
+        riskId = RiskIdLib.toRiskId(productNftId, id);
+        IRisk.RiskInfo memory riskInfo = IRisk.RiskInfo({
+            productNftId: productNftId, 
+            createdAt: TimestampLib.current(),
+            data: data});
 
-        instance.getInstanceStore().createRisk(
+        instance.getProductStore().createRisk(
             riskId,
             riskInfo
         );
+
+        // add risk to RiskSet
+        RiskSet riskSet = instance.getRiskSet();
+        riskSet.add(riskId);
+
+        emit LogRiskServiceRiskCreated(productNftId, riskId);
     }
 
 
@@ -69,29 +75,115 @@ contract RiskService is
         RiskId riskId,
         bytes memory data
     )
-        external
+        external 
+        virtual
+        restricted()
     {
-        (,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
-        InstanceReader instanceReader = instance.getInstanceReader();
+        // checks
+        (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
 
+        // effects
+        InstanceReader instanceReader = instance.getInstanceReader();
         IRisk.RiskInfo memory riskInfo = instanceReader.getRiskInfo(riskId);
+
+        if (riskInfo.productNftId != productNftId) {
+            revert ErrorRiskServiceRiskProductMismatch(riskId, riskInfo.productNftId, productNftId);
+        }
+
         riskInfo.data = data;
-        instance.getInstanceStore().updateRisk(riskId, riskInfo, KEEP_STATE());
+        instance.getProductStore().updateRisk(riskId, riskInfo, KEEP_STATE());
+
+        emit LogRiskServiceRiskUpdated(productNftId, riskId);
     }
 
 
-    function updateRiskState(
+    /// @inheritdoc IRiskService
+    function setRiskLocked(
         RiskId riskId,
-        StateId state
+        bool locked
     )
-        external
+        external 
+        virtual
+        restricted()
+    {
+        // checks
+        (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
+
+        if (!instance.getRiskSet().hasRisk(productNftId, riskId)) {
+            revert ErrorRiskServiceUnknownRisk(productNftId, riskId);
+        }
+
+        if (instance.getInstanceReader().getRiskState(riskId) != ACTIVE()) {
+            revert ErrorRiskServiceRiskNotActive(productNftId, riskId);
+        }
+
+        if (locked) {
+            instance.getRiskSet().deactivate(riskId);
+            emit LogRiskServiceRiskLocked(productNftId, riskId);
+        } else {
+            instance.getRiskSet().activate(riskId);
+            emit LogRiskServiceRiskUnlocked(productNftId, riskId);
+        }
+    }
+
+    /// @inheritdoc IRiskService
+    function closeRisk(
+        RiskId riskId
+    )
+        external 
+        virtual
+        restricted()
+    {
+        // checks
+        (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
+        (bool exists, bool active) = instance.getRiskSet().checkRisk(productNftId, riskId);
+
+        if (!exists) {
+            revert ErrorRiskServiceUnknownRisk(productNftId, riskId);
+        }
+
+        if (active) {
+            revert ErrorRiskServiceRiskNotLocked(productNftId, riskId);
+        }
+
+        // effects
+        instance.getProductStore().updateRiskState(riskId, CLOSED());
+
+        emit LogRiskServiceRiskClosed(productNftId, riskId);
+    }
+
+    function _getAndVerifyActiveComponent(ObjectType expectedType) 
+        internal 
+        view 
+        returns (
+            NftId componentNftId,
+            IInstance instance
+        )
     {
-        (,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
-        instance.getInstanceStore().updateRiskState(riskId, state);
+        IRegistry.ObjectInfo memory info;
+        address instanceAddress;
+        bool isActive = true;
+
+        if (expectedType != COMPONENT()) {
+            (info, instanceAddress) = ContractLib.getAndVerifyComponent(
+                getRegistry(),
+                msg.sender, // caller
+                expectedType,
+                isActive); 
+        } else {
+            (info, instanceAddress) = ContractLib.getAndVerifyAnyComponent(
+                getRegistry(),
+                msg.sender,
+                isActive); 
+        }
+
+        // get component nft id and instance
+        componentNftId = info.nftId;
+        instance = IInstance(instanceAddress);
     }
 
 
     function _getDomain() internal pure override returns(ObjectType) {
-        return PRODUCT();
+        return RISK();
     }
 }