@etherisc/gif-next 0.0.2-a714036-117 → 0.0.2-a78920e-322

package/contracts/product/IClaimService.sol

@@ -23,16 +23,20 @@ interface IClaimService is
     event LogClaimServiceClaimSubmitted(NftId policyNftId, ClaimId claimId, Amount claimAmount);
     event LogClaimServiceClaimConfirmed(NftId policyNftId, ClaimId claimId, Amount confirmedAmount);
     event LogClaimServiceClaimDeclined(NftId policyNftId, ClaimId claimId);
+    event LogClaimServiceClaimRevoked(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);
+    event LogClaimServicePayoutCreated(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary);
+    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary, Amount netAmount, Amount processingFeeAmount);
+    error ErrorClaimServiceBeneficiarySet(NftId policyNftId, PayoutId payoutId, address beneficiary);
 
     error ErrorClaimServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
     error ErrorClaimServicePolicyNotOpen(NftId policyNftId);
     error ErrorClaimServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
+    error ErrorClaimServiceBeneficiaryIsZero(NftId policyNftId, ClaimId claimId);
+    error ErrorClaimsServicePayoutAmountIsZero(NftId policyNftId, PayoutId payoutId);
 
-    error ErrorClaimServiceClaimWithOpenPayouts(NftId policyNftId, ClaimId claimId, uint8 openPayouts);
+    error ErrorClaimServiceClaimWithOpenPayouts(NftId policyNftId, ClaimId claimId, uint24 openPayouts);
     error ErrorClaimServiceClaimWithMissingPayouts(NftId policyNftId, ClaimId claimId, Amount claimAmount, Amount paidAmount);
     error ErrorClaimServiceClaimNotInExpectedState(NftId policyNftId, ClaimId claimId, StateId expectedState, StateId actualState);
 
@@ -46,9 +50,6 @@ interface IClaimService is
     ) 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(
@@ -58,6 +59,14 @@ interface IClaimService is
     ) external;
 
 
+    /// @dev revokes the specified claim
+    /// function can only be called by product, policy needs to match with calling product
+    function revoke(
+        NftId policyNftId, 
+        ClaimId claimId
+    ) 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(
@@ -76,7 +85,8 @@ interface IClaimService is
     ) external;
 
 
-    /// @dev creates a new payout for the specified claim
+    /// @dev Creates a new payout for the specified claim.
+    /// The beneficiary is the holder of the policy NFT
     /// 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(
@@ -89,6 +99,20 @@ interface IClaimService is
         returns (PayoutId payoutId);
 
 
+    /// @dev Creates a new payout for the specified claim and beneficiary.
+    /// 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 createPayoutForBeneficiary(
+        NftId policyNftId, 
+        ClaimId claimId,
+        Amount amount,
+        address beneficiary,
+        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

package/contracts/product/IPolicyService.sol

@@ -1,68 +1,64 @@
 // 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 {Amount} from "../type/Amount.sol";
-import {ClaimId} from "../type/ClaimId.sol";
+import {IInstance} from "../instance/IInstance.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 {
 
+    event LogPolicyServicePolicyCreated(NftId policyNftId, Amount premiumAmount, Timestamp activatedAt);
+    event LogPolicyServicePolicyDeclined(NftId policyNftId);
+    event LogPolicyServicePolicyPremiumCollected(NftId policyNftId, Amount premiumAmount);
+    event LogPolicyServicePolicyActivated(NftId policyNftId, Timestamp activatedAt);
+    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp originalExpiredAt, Timestamp expiredAt);
+    event LogPolicyServicePolicyClosed(NftId policyNftId);
+
     error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
     error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
-    error ErrorPolicyServicePolicyStateNotCollateralizedOrApplied(NftId applicationNftId);
+    error ErrorPolicyServicePolicyStateNotCollateralized(NftId applicationNftId);
+    error ErrorPolicyServicePolicyAlreadyActivated(NftId policyNftId);
 
-    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 ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId, Amount premiumPaidAmount);
-    error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
-    error ErrorIPolicyServicePolicyAlreadyClosed(NftId policyNftId);
-    error ErrorIPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
-    error ErrorPolicyServicePremiumNotFullyPaid(NftId policyNftId, Amount premiumAmount, Amount premiumPaidAmount);
-    error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
-    error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
-    error ErrorIPolicyServicePolicyExpirationTooLate(NftId policyNftId, Timestamp upperLimit, Timestamp expiredAt);
-    error ErrorIPolicyServicePolicyExpirationTooEarly(NftId policyNftId, Timestamp lowerLimit, Timestamp expiredAt);
+    error ErrorPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId);
+    error ErrorPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+    error ErrorPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
+    error ErrorPolicyServicePremiumNotPaid(NftId policyNftId, Amount premiumAmount);
+    error ErrorPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
+    error ErrorPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
+    error ErrorPolicyServicePolicyExpirationTooLate(NftId policyNftId, Timestamp upperLimit, Timestamp expiredAt);
+    error ErrorPolicyServicePolicyExpirationTooEarly(NftId policyNftId, Timestamp lowerLimit, Timestamp expiredAt);
 
     error ErrorPolicyServicePremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount recalculatedPremiumAmount);
     error ErrorPolicyServiceTransferredPremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount transferredPremiumAmount);
 
-    event LogPolicyServicePolicyDeclined(NftId policyNftId);
-    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);
-
-    /// @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 collateralized in applied state
-    /// only the related product may collateralize an application
-    function collateralize(
-        NftId policyNftId,
-        bool requirePremiumPayment,
+    /// @dev creates the policy from {applicationNftId}. 
+    /// After successful completion of the function the policy can be referenced using the application NftId.
+    /// Locks the sum insured amount in the pool, but does not transfer tokens. Call collectPremium to transfer tokens. 
+    /// Sets the policy state to collateralized.
+    /// Optionally activates the policy if activateAt is a non-zero timestamp.
+    /// only the related product may create a policy from an application
+    function createPolicy(
+        NftId applicationNftId,
         Timestamp activateAt
-    ) external;
+    )
+        external
+        returns (Amount premiumAmount);
 
     /// @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
+    /// @dev collects the premium token for the specified policy (must be in COLLATERALIZED state)
     function collectPremium(NftId policyNftId, Timestamp activateAt) external;
 
     /// @dev activates the specified policy and sets the activation date in the policy metadata
@@ -76,6 +72,8 @@ interface IPolicyService is IService {
     /// @return expiredAt the effective expiry date
     function expire(NftId policyNftId, Timestamp expireAt) external returns (Timestamp expiredAt);
 
+    function expirePolicy(IInstance instance, NftId policyNftId, Timestamp expireAt) external returns (Timestamp expiredAt);
+
     /// @dev closes the specified policy and sets the closed data in the policy metadata
     /// a policy can only be closed when it has been expired. in addition, it must not have any open claims
     /// this function can only be called by a product. the policy needs to match with the calling product

package/contracts/product/IPricingService.sol

@@ -14,15 +14,15 @@ interface IPricingService is IService
 {
 
     error ErrorPricingServiceTargetWalletAmountsMismatch();
-    error ErrorIPricingServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
-    error ErrorIPricingServiceFeeCalculationMismatch(
-                uint256 distributionFeeFixAmount,
-                uint256 distributionFeeVarAmount,
-                uint256 distributionOwnerFeeFixAmount,
-                uint256 distributionOwnerFeeVarAmount,
-                uint256 commissionAmount,
-                uint256 discountAmount
-            );
+    error ErrorPricingServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
+    error ErrorPricingServiceFeeCalculationMismatch(
+        Amount distributionFeeFixAmount,
+        Amount distributionFeeVarAmount,
+        Amount distributionOwnerFeeFixAmount,
+        Amount distributionOwnerFeeVarAmount,
+        Amount commissionAmount,
+        Amount discountAmount
+    );
 
     function calculatePremium(
         NftId productNftId,
@@ -35,5 +35,5 @@ interface IPricingService is IService
     )
         external
         view
-        returns (IPolicy.Premium memory premium);
+        returns (IPolicy.PremiumInfo memory premium);
 }

package/contracts/product/IProductComponent.sol

@@ -2,10 +2,11 @@
 pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
-import {Fee} from "../type/Fee.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 import {ReferralId} from "../type/Referral.sol";
 import {RiskId} from "../type/RiskId.sol";
 import {Seconds} from "../type/Seconds.sol";
@@ -14,6 +15,23 @@ interface IProductComponent is
     IInstanceLinkedComponent
 {
 
+    // @dev register a new component for this product cluster.
+    function registerComponent(address component)
+        external
+        returns (NftId componentNftId);
+
+    /// @dev Callback function to inform product compnent about arrival of funding for a claim.
+    /// The callback is called by the pool service after the corresponding pool triggers this function.
+    /// The callback is only called when the product's property isProcessingFundedClaims is set.
+    function processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    ) external;
+
+
+    /// @dev Calculates the premium amount for the provided application data.
+    /// The returned premium amounts takes into account potential discounts and fees.
     function calculatePremium(
         Amount sumInsuredAmount,
         RiskId riskId,
@@ -23,6 +41,10 @@ interface IProductComponent is
         ReferralId referralId
     ) external view returns (Amount premiumAmount);
 
+
+    /// @dev Calculates the net premium amount for the provided application data.
+    /// The returned net premium amounts only covers the cost of collateralizing the application.
+    /// This amount purely depends on the use case specific risk and does not include any fees/commission.
     function calculateNetPremium(
         Amount sumInsuredAmount,
         RiskId riskId,
@@ -30,9 +52,6 @@ interface IProductComponent is
         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 → IRiskService.sol}

@@ -12,7 +12,7 @@ import {Timestamp} from "../type/Timestamp.sol";
 import {UFixed} from "../type/UFixed.sol";
 import {Fee} from "../type/Fee.sol";
 
-interface IProductService is IService {
+interface IRiskService is IService {
 
     function createRisk(
         RiskId riskId,