@etherisc/gif-next 0.0.2-708facd-459 → 0.0.2-70b1050-183

package/contracts/product/IPolicyService.sol

@@ -1,54 +1,52 @@
 // 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 {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 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);
 
-    /// @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;
 
@@ -57,18 +55,19 @@ interface IPolicyService is IService {
     /// 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
     /// 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
+    /// @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
     /// 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
-    function expire(NftId policyNftId) external;
+    /// @return expiredAt the effective expiry date
+    function expire(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

package/contracts/product/IPricingService.sol

@@ -16,12 +16,12 @@ 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
+                Amount distributionFeeFixAmount,
+                Amount distributionFeeVarAmount,
+                Amount distributionOwnerFeeFixAmount,
+                Amount distributionOwnerFeeVarAmount,
+                Amount commissionAmount,
+                Amount discountAmount
             );
 
     function calculatePremium(
@@ -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,7 +2,6 @@
 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";
@@ -36,4 +35,5 @@ interface IProductComponent is
 
     /// @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,