@etherisc/gif-next 0.0.2-f12cf4d-104 → 0.0.2-f13d67f-541

package/contracts/product/ClaimServiceManager.sol

@@ -17,7 +17,7 @@ contract ClaimServiceManager is ProxyManager {
     ) 
     {
         ClaimService svc = new ClaimService{salt: salt}();
-        bytes memory data = abi.encode(registry, authority);
+        bytes memory data = abi.encode(authority, registry);
         IVersionable versionable = initialize(
             registry,
             address(svc), 

package/contracts/product/IApplicationService.sol

@@ -6,7 +6,6 @@ import {IService} from "../shared/IService.sol";
 
 import {Amount} from "../type/Amount.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";
@@ -15,8 +14,34 @@ import {Seconds} from "../type/Seconds.sol";
 /// only product components may call transaction functions
 interface IApplicationService is IService {
     
-    error ErrorApplicationServiceNotProduct(NftId callerNftId, ObjectType callerType);
-    error ErrorApplicationServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
+    event LogApplicationServiceApplicationCreated(
+        NftId applicationNftId,
+        NftId productNftId,
+        NftId bundleNftId, 
+        RiskId riskId,
+        ReferralId referralId,
+        address applicationOwner,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime);
+    event LogApplicationServiceApplicationRenewed(NftId policyNftId, NftId bundleNftId);
+    event LogApplicationServiceApplicationAdjusted(
+        NftId applicationNftId, 
+        NftId bundleNftId, 
+        RiskId riskId, 
+        ReferralId referralId, 
+        Amount sumInsuredAmount, 
+        Seconds lifetime);
+    event LogApplicationServiceApplicationRevoked(NftId applicationNftId);
+
+    // _checkLinkedApplicationParameters
+    error ErrorApplicationServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
+    error ErrorApplicationServiceRiskUnknown(RiskId riskId, NftId productNftId);
+    error ErrorApplicationServiceRiskLocked(RiskId riskId, NftId productNftId);
+    error ErrorApplicationServiceBundleUnknown(NftId bundleNftId, NftId poolNftId);
+    error ErrorApplicationServiceBundleLocked(NftId bundleNftId, NftId poolNftId);
+    error ErrorApplicationServiceReferralInvalid(NftId productNftId, NftId distributionNftId, ReferralId referralId);
+    
 
     /// @dev creates a new application based on the specified attributes
     /// may only be called by a product component

package/contracts/product/IClaimService.sol

@@ -19,19 +19,21 @@ import {Fee} from "../type/Fee.sol";
 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 LogClaimServiceClaimRevoked(NftId policyNftId, ClaimId claimId);
-    event LogClaimServiceClaimClosed(NftId policyNftId, ClaimId claimId);
+    event LogClaimServiceClaimCancelled(NftId policyNftId, ClaimId claimId);
 
     event LogClaimServicePayoutCreated(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary);
-    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount, address beneficiary, Amount netAmount, Amount processingFeeAmount);
+    event LogClaimServicePayoutProcessed(NftId policyNftId, PayoutId payoutId, Amount amount);
+    event LogClaimServicePayoutCancelled(NftId policyNftId, PayoutId payoutId);
+
     error ErrorClaimServiceBeneficiarySet(NftId policyNftId, PayoutId payoutId, address beneficiary);
 
     error ErrorClaimServicePolicyProductMismatch(NftId policyNftId, NftId expectedProduct, NftId actualProduct);
     error ErrorClaimServicePolicyNotOpen(NftId policyNftId);
+    error ErrorClaimServiceClaimAmountIsZero(NftId policyNftId);
     error ErrorClaimServiceClaimExceedsSumInsured(NftId policyNftId, Amount sumInsured, Amount payoutsIncludingClaimAmount);
     error ErrorClaimServiceBeneficiaryIsZero(NftId policyNftId, ClaimId claimId);
     error ErrorClaimsServicePayoutAmountIsZero(NftId policyNftId, PayoutId payoutId);
@@ -40,6 +42,10 @@ interface IClaimService is
     error ErrorClaimServiceClaimWithMissingPayouts(NftId policyNftId, ClaimId claimId, Amount claimAmount, Amount paidAmount);
     error ErrorClaimServiceClaimNotInExpectedState(NftId policyNftId, ClaimId claimId, StateId expectedState, StateId actualState);
 
+    error ErrorClaimServiceClaimNotConfirmed(NftId policyNftId, ClaimId claimId, StateId actualState);
+    error ErrorClaimServicePayoutExceedsClaimAmount(NftId policyNftId, ClaimId claimId, Amount claimAmount, Amount totalPayoutAmount);
+    error ErrorClaimServicePayoutNotExpected(NftId policyNftId, PayoutId payoutId, 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
@@ -77,9 +83,10 @@ interface IClaimService is
     ) external;
 
 
-    /// @dev closes the specified claim
+    /// @dev cancels a confirmed claim before it has been fully paid out. 
+    /// Can only be called when there are not pending payouts
     /// function can only be called by product, policy needs to match with calling product
-    function close(
+    function cancelConfirmedClaim(
         NftId policyNftId, 
         ClaimId claimId
     ) external;
@@ -119,5 +126,11 @@ interface IClaimService is
     function processPayout(
         NftId policyNftId, 
         PayoutId payoutId
+    ) external returns (Amount netPayoutAmount, Amount processingFeeAmount);
+
+    /// @dev cancels the specified payout. no tokens are moved, payout is set to cancelled. 
+    function cancelPayout(
+        NftId policyNftId, 
+        PayoutId payoutId
     ) external;
 }

package/contracts/product/IPolicyService.sol

@@ -15,21 +15,25 @@ interface IPolicyService is IService {
     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 LogPolicyServicePolicyActivatedUpdated(NftId policyNftId, Timestamp activatedAt);
+    event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);
     event LogPolicyServicePolicyClosed(NftId policyNftId);
 
+    error LogPolicyServiceMaxPremiumAmountExceeded(NftId policyNftId, Amount maxPremiumAmount, Amount premiumAmount);
     error ErrorPolicyServicePolicyProductMismatch(NftId applicationNftId, NftId expectedProductNftId, NftId actualProductNftId);
     error ErrorPolicyServicePolicyStateNotApplied(NftId applicationNftId);
     error ErrorPolicyServicePolicyStateNotCollateralized(NftId applicationNftId);
     error ErrorPolicyServicePolicyAlreadyActivated(NftId policyNftId);
 
-    error ErrorPolicyServiceBalanceInsufficient(address policyOwner, uint256 premiumAmount, uint256 balance);
-    error ErrorPolicyServiceAllowanceInsufficient(address policyOwner, address tokenHandler, uint256 premiumAmount, uint256 allowance);
-
+    error ErrorPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorPolicyServicePolicyActivationTooEarly(NftId policyNftId, Timestamp lowerLimit, Timestamp activatedAt);
+    error ErrorPolicyServicePolicyActivationTooLate(NftId policyNftId, Timestamp upperLimit, Timestamp activatedAt);
+    
     error ErrorPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
     error ErrorPolicyServicePremiumAlreadyPaid(NftId policyNftId);
-    error ErrorPolicyServicePolicyNotActivated(NftId policyNftId);
-    error ErrorPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+
+    error ErrorPolicyServicePolicyNotCloseable(NftId policyNftId);
+
     error ErrorPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
     error ErrorPolicyServicePremiumNotPaid(NftId policyNftId, Amount premiumAmount);
     error ErrorPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
@@ -41,14 +45,21 @@ interface IPolicyService is IService {
     error ErrorPolicyServiceTransferredPremiumMismatch(NftId policyNftId, Amount expectedPremiumAmount, Amount transferredPremiumAmount);
 
     /// @dev creates the policy from {applicationNftId}. 
+    /// @param applicationNftId the application NftId
+    /// @param activateAt the timestamp when the policy should be activated
+    /// @param maxPremiumAmount the maximum premium amount that the policy holder is willing to pay
+    /// During policy creation, the effective premium amount is calculated based on the provided parameters. If this
+    /// amount is higher than the maxPremiumAmount, the function will revert.
     /// 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
+    /// @return premiumAmount the effective premium amount
     function createPolicy(
         NftId applicationNftId,
-        Timestamp activateAt
+        Timestamp activateAt,
+        Amount maxPremiumAmount
     )
         external
         returns (Amount premiumAmount);
@@ -65,18 +76,27 @@ interface IPolicyService is IService {
     /// to activate a policy it needs to be in underwritten state
     function activate(NftId policyNftId, Timestamp activateAt) external;
 
-    /// @dev expires the specified policy and sets the expiry date in the policy metadata. If expiry date is set to 0, then the earliest possible expiry date (current blocktime) is set
+    /// @dev adjusts the activation date of the specified policy and sets the new activation date in the policy metadata
+    /// to adjust the activation date of a policy it needs to have an activation date set. 
+    /// the new activation date must not be before the current block timestamp or after the expiry date
+    function adjustActivation(NftId policyNftId, Timestamp newActivateAt) external;
+
+    /// @dev Expires the specified policy and sets the expiry date in the policy metadata. 
+    /// Function consumers are products.
+    /// If expiry date is set to 0, then the earliest possible expiry date (current blocktime) is set
     /// to expire a policy it must be in active state, policies may be expired even when the predefined expiry date is still in the future
     /// 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
     /// @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
+    /// @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
     function close(NftId policyNftId) external;
 
+    /// @dev Expires the specified policy and sets the expiry date in the policy metadata. 
+    /// Function consumers is claim service.
+    function expirePolicy(IInstance instance, NftId policyNftId, Timestamp expireAt) external returns (Timestamp expiredAt);
+
 }

package/contracts/product/IPricingService.sol

@@ -14,6 +14,7 @@ interface IPricingService is IService
 {
 
     error ErrorPricingServiceTargetWalletAmountsMismatch();
+    error ErrorPricingServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
     error ErrorPricingServiceBundlePoolMismatch(NftId bundleNftId, NftId bundlePoolNftId, NftId poolNftId);
     error ErrorPricingServiceFeeCalculationMismatch(
         Amount distributionFeeFixAmount,

package/contracts/product/IProductComponent.sol

@@ -53,7 +53,10 @@ interface IProductComponent is
     ) external view returns (Amount netPremiumAmount);    
 
 
-    /// @dev returns initial pool specific infos for this pool
+    /// @dev returns initial product specific infos 
     function getInitialProductInfo() external view returns (IComponents.ProductInfo memory info);
+
+    /// @dev returns initial fee infos
+    function getInitialFeeInfo() external view returns (IComponents.FeeInfo memory info);
     
 }

package/contracts/product/IRiskService.sol

@@ -1,23 +1,32 @@
 // 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 IRiskService is IService {
 
+    event LogRiskServiceRiskCreated(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskUpdated(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskLocked(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskUnlocked(NftId productNftId, RiskId riskId);
+    event LogRiskServiceRiskClosed(NftId productNftId, RiskId riskId);
+    
+    error ErrorRiskServiceRiskProductMismatch(RiskId riskId, NftId riskProductNftId, NftId productNftId);
+    error ErrorRiskServiceRiskNotActive(NftId productNftId, RiskId riskId);
+    error ErrorRiskServiceUnknownRisk(NftId productNftId, RiskId riskId);
+    error ErrorRiskServiceRiskNotLocked(NftId productNftId, RiskId riskId);
+
+    /// @dev Create a new risk with the given id and provided data. 
+    /// The key of the risk derived from the risk id in comination with the product NftId. 
+    /// Risk data is stored in the instance store. 
     function createRisk(
-        RiskId riskId,
+        bytes32 id,
         bytes memory data
-    ) external;
+    ) external returns (RiskId riskId);
 
 
     function updateRisk(
@@ -25,9 +34,15 @@ interface IRiskService is IService {
         bytes memory data
     ) external;
 
-
-    function updateRiskState(
+    /// @dev Locks/unlocks the risk with the given id.
+    /// No new policies can be underwritten for a locked risk.
+    function setRiskLocked(
         RiskId riskId,
-        StateId newState
+        bool locked
+    ) external;
+
+    /// @dev Close the risk with the given id.
+    function closeRisk(
+        RiskId riskId
     ) external;
 }