@etherisc/gif-next 0.0.2-f080b71-868 → 0.0.2-f083368-470

package/contracts/product/IClaimService.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IInstance} from "../instance/IInstance.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IService} from "../shared/IService.sol";
+
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {NftId} from "../type/NftId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {Fee} from "../type/Fee.sol";
+
+/// @dev gif service responsible for creating claims and payouts
+/// only product components may call transaction functions
+interface IClaimService is
+    IService
+{
+
+    event LogClaimServiceClaimSubmitted(NftId policyNftId, ClaimId claimId, Amount claimAmount);
+    event LogClaimServiceClaimConfirmed(NftId policyNftId, ClaimId claimId, Amount confirmedAmount);
+    event LogClaimServiceClaimDeclined(NftId policyNftId, ClaimId claimId);
+    event LogClaimServiceClaimClosed(NftId policyNftId, ClaimId claimId);
+
+    event LogClaimServicePayoutCreated(NftId policyNftId, PayoutId payoutId, Amount amount);
+    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary, Amount netAmount);
+
+    error ErrorClaimServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
+    error ErrorClaimServicePolicyNotOpen(NftId policyNftId);
+    error ErrorClaimServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
+
+    error ErrorClaimServiceClaimWithOpenPayouts(NftId policyNftId, ClaimId claimId, uint8 openPayouts);
+    error ErrorClaimServiceClaimWithMissingPayouts(NftId policyNftId, ClaimId claimId, Amount claimAmount, Amount paidAmount);
+    error ErrorClaimServiceClaimNotInExpectedState(NftId policyNftId, ClaimId claimId, StateId expectedState, StateId actualState);
+
+    /// @dev create a new claim for the specified policy
+    /// returns the id of the newly created claim
+    /// function can only be called by product, policy needs to match with calling product
+    function submit(
+        NftId policyNftId, 
+        Amount claimAmount,
+        bytes memory claimData
+    ) external returns (ClaimId claimId);
+
+
+    // TODO add claim revoke functionality
+
+
+    /// @dev declines the specified claim
+    /// function can only be called by product, policy needs to match with calling product
+    function decline(
+        NftId policyNftId, 
+        ClaimId claimId,
+        bytes memory data // claim processing data
+    ) external;
+
+
+    /// @dev confirms the specified claim and specifies the payout amount
+    /// function can only be called by product, policy needs to match with calling product
+    function confirm(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount confirmedAmount,
+        bytes memory data // claim processing data
+    ) external;
+
+
+    /// @dev closes the specified claim
+    /// function can only be called by product, policy needs to match with calling product
+    function close(
+        NftId policyNftId, 
+        ClaimId claimId
+    ) external;
+
+
+    /// @dev creates a new payout for the specified claim
+    /// returns the id of the newly created payout, this id is unique for the specified policy
+    /// function can only be called by product, policy needs to match with calling product
+    function createPayout(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        bytes memory data
+    )
+        external
+        returns (PayoutId payoutId);
+
+
+    /// @dev processes the specified payout
+    /// this includes moving the payout token to the beneficiary (default: policy holder)
+    /// function can only be called by product, policy needs to match with calling product
+    function processPayout(
+        NftId policyNftId, 
+        PayoutId payoutId
+    ) external;
+}

package/contracts/{instance/service → product}/IPolicyService.sol

@@ -1,52 +1,62 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {IRisk} from "../module/IRisk.sol";
-import {IService} from "../../shared/IService.sol";
+import {IRisk} from "../instance/module/IRisk.sol";
+import {IService} from "../shared/IService.sol";
 
-import {NftId} from "../../types/NftId.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
-import {Seconds} from "../../types/Seconds.sol";
-import {StateId} from "../../types/StateId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
-import {UFixed} from "../../types/UFixed.sol";
-import {Fee} from "../../types/Fee.sol";
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {ReferralId} from "../type/Referral.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 {UFixed} from "../type/UFixed.sol";
+import {Fee} from "../type/Fee.sol";
 
 interface IPolicyService is IService {
-    
+
+    error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
+    error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
+    error ErrorPolicyServicePolicyStateNotCollateralizedOrApplied(NftId applicationNftId);
+
+    error ErrorPolicyServicePremiumHigherThanExpected(Amount premiumExpectedAmount, Amount premiumToBePaidAmount);
+    error ErrorPolicyServiceBalanceInsufficient(address policyOwner, uint256 premiumAmount, uint256 balance);
+    error ErrorPolicyServiceAllowanceInsufficient(address policyOwner, address tokenHandler, uint256 premiumAmount, uint256 allowance);
+
     error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
-    error ErrorIPolicyServicePremiumAlreadyPaid(NftId policyNftId, uint256 premiumPaidAmount);
+    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId, Amount premiumPaidAmount);
     error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
     error ErrorIPolicyServicePolicyAlreadyClosed(NftId policyNftId);
     error ErrorIPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
-    error ErrorIPolicyServicePremiumNotFullyPaid(NftId policyNftId, uint256 premiumAmount, uint256 premiumPaidAmount);
+    error ErrorPolicyServicePremiumNotFullyPaid(NftId policyNftId, Amount premiumAmount, Amount premiumPaidAmount);
     error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
     error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
 
-    error ErrorIPolicyServicePremiumMismatch(NftId policyNftId, uint256 premiumAmount, uint256 recalculatedPremiumAmount);
-    error ErrorIPolicyServicePolicyProductMismatch(NftId policyNftId, NftId policyProductNftId, NftId productNftId);
-    error ErrorIPolicyServicePolicyStateInvalid(NftId policyNftId, StateId expectedState, StateId foundState);
-
-    /// @dev declines an application represented by {policyNftId}
-    /// an application can only be declined in applied state
-    /// only the related product may decline an application
-    function decline(NftId policyNftId) external;
+    error ErrorPolicyServicePremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount recalculatedPremiumAmount);
+    error ErrorPolicyServiceTransferredPremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount transferredPremiumAmount);
 
-    /// @dev underwrites the policy represented by {policyNftId}
-    /// sets the policy state to underwritten
+    /// @dev collateralizes the policy represented by {policyNftId}
+    /// sets the policy state to collateralized
     /// may set the policy state to activated and set the activation date
     /// optionally collects premiums and activates the policy.
     /// - premium payment is only attempted if requirePremiumPayment is set to true
     /// - activation is only done if activateAt is a non-zero timestamp
-    /// an application can only be underwritten in applied state
-    /// only the related product may underwrite an application
-    function underwrite(
+    /// an application can only be collateralized in applied state
+    /// only the related product may collateralize an application
+    function collateralize(
         NftId policyNftId,
         bool requirePremiumPayment,
         Timestamp activateAt
     ) external;
 
+    /// @dev declines an application represented by {policyNftId}
+    /// an application can only be declined in applied state
+    /// only the related product may decline an application
+    function decline(NftId policyNftId) external;
+
     /// @dev collects the premium token for the specified policy
     function collectPremium(NftId policyNftId, Timestamp activateAt) external;
 
@@ -65,10 +75,4 @@ interface IPolicyService is IService {
     /// this function can only be called by a product. the policy needs to match with the calling product
     function close(NftId policyNftId) external;
 
-    // TODO move function to pool service
-    function calculateRequiredCollateral(
-        UFixed collateralizationLevel, 
-        uint256 sumInsuredAmount
-    ) external pure returns(uint256 collateralAmount);
-
 }

package/contracts/{instance/service → product}/IPricingService.sol

@@ -1,16 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {Seconds} from "../../types/Seconds.sol";
-import {NftId} from "../../types/NftId.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {NftId} from "../type/NftId.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {Amount} from "../type/Amount.sol";
 
 import {IService} from "./IApplicationService.sol";
-import {IPolicy} from "../module/IPolicy.sol";
+import {IPolicy} from "../instance/module/IPolicy.sol";
 
 interface IPricingService is IService
 {
+
+    error ErrorPricingServiceTargetWalletAmountsMismatch();
     error ErrorIPricingServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
     error ErrorIPricingServiceFeeCalculationMismatch(
                 uint256 distributionFeeFixAmount,
@@ -23,14 +26,14 @@ interface IPricingService is IService
 
     function calculatePremium(
         NftId productNftId,
-        NftId bundleNftId,
         RiskId riskId,
-        ReferralId referralId,
-        uint256 sumInsuredAmount,
+        Amount sumInsuredAmount,
         Seconds lifetime,
-        bytes memory applicationData
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
     )
         external
         view
         returns (IPolicy.Premium memory premium);
-}
+}

package/contracts/product/IProductComponent.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../type/Amount.sol";
+import {Fee} from "../type/Fee.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {NftId} from "../type/NftId.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {Seconds} from "../type/Seconds.sol";
+
+interface IProductComponent is
+    IInstanceLinkedComponent
+{
+
+    function calculatePremium(
+        Amount sumInsuredAmount,
+        RiskId riskId,
+        Seconds lifetime,
+        bytes memory applicationData,
+        NftId bundleNftId,
+        ReferralId referralId
+    ) external view returns (Amount premiumAmount);
+
+    function calculateNetPremium(
+        Amount sumInsuredAmount,
+        RiskId riskId,
+        Seconds lifetime,
+        bytes memory applicationData
+    ) external view returns (Amount netPremiumAmount);    
+
+    function getPoolNftId() external view returns (NftId poolNftId);
+    function getDistributionNftId() external view returns (NftId distributionNftId);
+
+
+    /// @dev returns initial pool specific infos for this pool
+    function getInitialProductInfo() external view returns (IComponents.ProductInfo memory info);
+    
+}

package/contracts/product/IProductService.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IRisk} from "../instance/module/IRisk.sol";
+import {IService} from "../shared/IService.sol";
+
+import {NftId} from "../type/NftId.sol";
+import {ReferralId} from "../type/Referral.sol";
+import {RiskId} from "../type/RiskId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {Fee} from "../type/Fee.sol";
+
+interface IProductService is IService {
+
+    function createRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRisk(
+        RiskId riskId,
+        bytes memory data
+    ) external;
+
+
+    function updateRiskState(
+        RiskId riskId,
+        StateId newState
+    ) external;
+}